@openmrs/esm-login-app 3.3.2-pre.9 → 3.4.0

package/dist/762.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"762.js","mappings":"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","sources":["webpack://@openmrs/esm-login-app/../../../node_modules/css-loader/dist/runtime/api.js","webpack://@openmrs/esm-login-app/../../../node_modules/css-loader/dist/runtime/cssWithMappingToString.js","webpack://@openmrs/esm-login-app/../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://@openmrs/esm-login-app/../../../node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://@openmrs/esm-login-app/../../../node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://@openmrs/esm-login-app/../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://@openmrs/esm-login-app/../../../node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://@openmrs/esm-login-app/../../../node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/isObject.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_freeGlobal.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_root.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/now.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_trimmedEndIndex.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_baseTrim.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_Symbol.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_getRawTag.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_objectToString.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/_baseGetTag.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/toNumber.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/isSymbol.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/isObjectLike.js","webpack://@openmrs/esm-login-app/../../../node_modules/lodash-es/debounce.js","webpack://@openmrs/esm-login-app/../../../node_modules/swr/dist/index.mjs","webpack://@openmrs/esm-login-app/../../../node_modules/swr/infinite/dist/index.mjs"],"sourcesContent":["\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\n// css base code, injected by the css-loader\n// eslint-disable-next-line func-names\nmodule.exports = function (cssWithMappingToString) {\n  var list = []; // return the list of modules as css string\n\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = cssWithMappingToString(item);\n\n      if (item[2]) {\n        return \"@media \".concat(item[2], \" {\").concat(content, \"}\");\n      }\n\n      return content;\n    }).join(\"\");\n  }; // import a list of modules into the list\n  // eslint-disable-next-line func-names\n\n\n  list.i = function (modules, mediaQuery, dedupe) {\n    if (typeof modules === \"string\") {\n      // eslint-disable-next-line no-param-reassign\n      modules = [[null, modules, \"\"]];\n    }\n\n    var alreadyImportedModules = {};\n\n    if (dedupe) {\n      for (var i = 0; i < this.length; i++) {\n        // eslint-disable-next-line prefer-destructuring\n        var id = this[i][0];\n\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n\n    for (var _i = 0; _i < modules.length; _i++) {\n      var item = [].concat(modules[_i]);\n\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        // eslint-disable-next-line no-continue\n        continue;\n      }\n\n      if (mediaQuery) {\n        if (!item[2]) {\n          item[2] = mediaQuery;\n        } else {\n          item[2] = \"\".concat(mediaQuery, \" and \").concat(item[2]);\n        }\n      }\n\n      list.push(item);\n    }\n  };\n\n  return list;\n};","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nmodule.exports = function cssWithMappingToString(item) {\n  var _item = _slicedToArray(item, 4),\n      content = _item[1],\n      cssMapping = _item[3];\n\n  if (!cssMapping) {\n    return content;\n  }\n\n  if (typeof btoa === \"function\") {\n    // eslint-disable-next-line no-undef\n    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n    var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n    var sourceMapping = \"/*# \".concat(data, \" */\");\n    var sourceURLs = cssMapping.sources.map(function (source) {\n      return \"/*# sourceURL=\".concat(cssMapping.sourceRoot || \"\").concat(source, \" */\");\n    });\n    return [content].concat(sourceURLs).concat([sourceMapping]).join(\"\\n\");\n  }\n\n  return [content].join(\"\\n\");\n};","\"use strict\";\n\nvar stylesInDOM = [];\n\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n\n  return result;\n}\n\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n\n    identifiers.push(identifier);\n  }\n\n  return identifiers;\n}\n\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n\n  return updater;\n}\n\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n\n    var newLastIdentifiers = modulesToDom(newList, options);\n\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n\n      var _index = getIndexByIdentifier(_identifier);\n\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\nvar memo = {};\n/* istanbul ignore next  */\n\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself\n\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n\n    memo[target] = styleTarget;\n  }\n\n  return memo[target];\n}\n/* istanbul ignore next  */\n\n\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n\n  target.appendChild(style);\n}\n\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\n\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\n\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n\n  var needLayer = typeof obj.layer !== \"undefined\";\n\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n\n  css += obj.css;\n\n  if (needLayer) {\n    css += \"}\";\n  }\n\n  if (obj.media) {\n    css += \"}\";\n  }\n\n  if (obj.supports) {\n    css += \"}\";\n  }\n\n  var sourceMap = obj.sourceMap;\n\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  } // For old IE\n\n  /* istanbul ignore if  */\n\n\n  options.styleTagTransform(css, styleElement, options.options);\n}\n\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n\n  styleElement.parentNode.removeChild(styleElement);\n}\n/* istanbul ignore next  */\n\n\nfunction domAPI(options) {\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\n\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\n\nmodule.exports = styleTagTransform;","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nexport default isObject;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nexport default now;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nexport default trimmedEndIndex;\n","import trimmedEndIndex from './_trimmedEndIndex.js';\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nexport default baseTrim;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","import baseTrim from './_baseTrim.js';\nimport isObject from './isObject.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nexport default toNumber;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nexport default isSymbol;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import isObject from './isObject.js';\nimport now from './now.js';\nimport toNumber from './toNumber.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nexport default debounce;\n","import { useEffect, useLayoutEffect, createContext, useContext, useState, createElement, useRef, useCallback, useDebugValue } from 'react';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nfunction __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\n\nvar noop = function () { };\n// Using noop() as the undefined value as undefined can possibly be replaced\n// by something else.  Prettier ignore and extra parentheses are necessary here\n// to ensure that tsc doesn't remove the __NOINLINE__ comment.\n// prettier-ignore\nvar UNDEFINED = ( /*#__NOINLINE__*/noop());\nvar OBJECT = Object;\nvar isUndefined = function (v) { return v === UNDEFINED; };\nvar isFunction = function (v) { return typeof v == 'function'; };\nvar mergeObjects = function (a, b) { return OBJECT.assign({}, a, b); };\nvar STR_UNDEFINED = 'undefined';\n// NOTE: Use function to guarantee it's re-evaluated between jsdom and node runtime for tests.\nvar hasWindow = function () { return typeof window != STR_UNDEFINED; };\nvar hasDocument = function () { return typeof document != STR_UNDEFINED; };\nvar hasRequestAnimationFrame = function () {\n    return hasWindow() && typeof window['requestAnimationFrame'] != STR_UNDEFINED;\n};\n\n// use WeakMap to store the object->key mapping\n// so the objects can be garbage collected.\n// WeakMap uses a hashtable under the hood, so the lookup\n// complexity is almost O(1).\nvar table = new WeakMap();\n// counter of the key\nvar counter = 0;\n// A stable hash implementation that supports:\n// - Fast and ensures unique hash properties\n// - Handles unserializable values\n// - Handles object key ordering\n// - Generates short results\n//\n// This is not a serialization function, and the result is not guaranteed to be\n// parsible.\nvar stableHash = function (arg) {\n    var type = typeof arg;\n    var constructor = arg && arg.constructor;\n    var isDate = constructor == Date;\n    var result;\n    var index;\n    if (OBJECT(arg) === arg && !isDate && constructor != RegExp) {\n        // Object/function, not null/date/regexp. Use WeakMap to store the id first.\n        // If it's already hashed, directly return the result.\n        result = table.get(arg);\n        if (result)\n            return result;\n        // Store the hash first for circular reference detection before entering the\n        // recursive `stableHash` calls.\n        // For other objects like set and map, we use this id directly as the hash.\n        result = ++counter + '~';\n        table.set(arg, result);\n        if (constructor == Array) {\n            // Array.\n            result = '@';\n            for (index = 0; index < arg.length; index++) {\n                result += stableHash(arg[index]) + ',';\n            }\n            table.set(arg, result);\n        }\n        if (constructor == OBJECT) {\n            // Object, sort keys.\n            result = '#';\n            var keys = OBJECT.keys(arg).sort();\n            while (!isUndefined((index = keys.pop()))) {\n                if (!isUndefined(arg[index])) {\n                    result += index + ':' + stableHash(arg[index]) + ',';\n                }\n            }\n            table.set(arg, result);\n        }\n    }\n    else {\n        result = isDate\n            ? arg.toJSON()\n            : type == 'symbol'\n                ? arg.toString()\n                : type == 'string'\n                    ? JSON.stringify(arg)\n                    : '' + arg;\n    }\n    return result;\n};\n\n/**\n * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,\n * it's not reliable to detect if the browser is currently online or offline\n * based on `navigator.onLine`.\n * As a work around, we always assume it's online on first load, and change\n * the status upon `online` or `offline` events.\n */\nvar online = true;\nvar isOnline = function () { return online; };\nvar hasWin = hasWindow();\nvar hasDoc = hasDocument();\n// For node and React Native, `add/removeEventListener` doesn't exist on window.\nvar onWindowEvent = hasWin && window.addEventListener\n    ? window.addEventListener.bind(window)\n    : noop;\nvar onDocumentEvent = hasDoc ? document.addEventListener.bind(document) : noop;\nvar offWindowEvent = hasWin && window.removeEventListener\n    ? window.removeEventListener.bind(window)\n    : noop;\nvar offDocumentEvent = hasDoc\n    ? document.removeEventListener.bind(document)\n    : noop;\nvar isVisible = function () {\n    var visibilityState = hasDoc && document.visibilityState;\n    return isUndefined(visibilityState) || visibilityState !== 'hidden';\n};\nvar initFocus = function (callback) {\n    // focus revalidate\n    onDocumentEvent('visibilitychange', callback);\n    onWindowEvent('focus', callback);\n    return function () {\n        offDocumentEvent('visibilitychange', callback);\n        offWindowEvent('focus', callback);\n    };\n};\nvar initReconnect = function (callback) {\n    // revalidate on reconnected\n    var onOnline = function () {\n        online = true;\n        callback();\n    };\n    // nothing to revalidate, just update the status\n    var onOffline = function () {\n        online = false;\n    };\n    onWindowEvent('online', onOnline);\n    onWindowEvent('offline', onOffline);\n    return function () {\n        offWindowEvent('online', onOnline);\n        offWindowEvent('offline', onOffline);\n    };\n};\nvar preset = {\n    isOnline: isOnline,\n    isVisible: isVisible\n};\nvar defaultConfigOptions = {\n    initFocus: initFocus,\n    initReconnect: initReconnect\n};\n\nvar IS_SERVER = !hasWindow() || 'Deno' in window;\n// Polyfill requestAnimationFrame\nvar rAF = function (f) {\n    return hasRequestAnimationFrame() ? window['requestAnimationFrame'](f) : setTimeout(f, 1);\n};\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\nvar useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;\n// This assignment is to extend the Navigator type to use effectiveType.\nvar navigatorConnection = typeof navigator !== 'undefined' &&\n    navigator.connection;\n// Adjust the config based on slow connection status (<= 70Kbps).\nvar slowConnection = !IS_SERVER &&\n    navigatorConnection &&\n    (['slow-2g', '2g'].includes(navigatorConnection.effectiveType) ||\n        navigatorConnection.saveData);\n\nvar serialize = function (key) {\n    if (isFunction(key)) {\n        try {\n            key = key();\n        }\n        catch (err) {\n            // dependencies not ready\n            key = '';\n        }\n    }\n    var args = [].concat(key);\n    // If key is not falsy, or not an empty array, hash it.\n    key =\n        typeof key == 'string'\n            ? key\n            : (Array.isArray(key) ? key.length : key)\n                ? stableHash(key)\n                : '';\n    var infoKey = key ? '$swr$' + key : '';\n    return [key, args, infoKey];\n};\n\n// Global state used to deduplicate requests and store listeners\nvar SWRGlobalState = new WeakMap();\n\nvar FOCUS_EVENT = 0;\nvar RECONNECT_EVENT = 1;\nvar MUTATE_EVENT = 2;\n\nvar broadcastState = function (cache, key, data, error, isValidating, revalidate, broadcast) {\n    if (broadcast === void 0) { broadcast = true; }\n    var _a = SWRGlobalState.get(cache), EVENT_REVALIDATORS = _a[0], STATE_UPDATERS = _a[1], FETCH = _a[3];\n    var revalidators = EVENT_REVALIDATORS[key];\n    var updaters = STATE_UPDATERS[key];\n    // Cache was populated, update states of all hooks.\n    if (broadcast && updaters) {\n        for (var i = 0; i < updaters.length; ++i) {\n            updaters[i](data, error, isValidating);\n        }\n    }\n    // If we also need to revalidate, only do it for the first hook.\n    if (revalidate) {\n        // Invalidate the key by deleting the concurrent request markers so new\n        // requests will not be deduped.\n        delete FETCH[key];\n        if (revalidators && revalidators[0]) {\n            return revalidators[0](MUTATE_EVENT).then(function () {\n                return cache.get(key);\n            });\n        }\n    }\n    return cache.get(key);\n};\n\n// Global timestamp.\nvar __timestamp = 0;\nvar getTimestamp = function () { return ++__timestamp; };\n\nvar internalMutate = function () {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return __awaiter(void 0, void 0, void 0, function () {\n        var cache, _key, _data, _opts, options, populateCache, revalidate, rollbackOnError, optimisticData, _a, key, keyInfo, _b, MUTATION, data, error, beforeMutationTs, hasOptimisticData, rollbackData, res;\n        return __generator(this, function (_c) {\n            switch (_c.label) {\n                case 0:\n                    cache = args[0], _key = args[1], _data = args[2], _opts = args[3];\n                    options = typeof _opts === 'boolean' ? { revalidate: _opts } : _opts || {};\n                    populateCache = isUndefined(options.populateCache)\n                        ? true\n                        : options.populateCache;\n                    revalidate = options.revalidate !== false;\n                    rollbackOnError = options.rollbackOnError !== false;\n                    optimisticData = options.optimisticData;\n                    _a = serialize(_key), key = _a[0], keyInfo = _a[2];\n                    if (!key)\n                        return [2 /*return*/];\n                    _b = SWRGlobalState.get(cache), MUTATION = _b[2];\n                    // If there is no new data provided, revalidate the key with current state.\n                    if (args.length < 3) {\n                        // Revalidate and broadcast state.\n                        return [2 /*return*/, broadcastState(cache, key, cache.get(key), UNDEFINED, UNDEFINED, revalidate, true)];\n                    }\n                    data = _data;\n                    beforeMutationTs = getTimestamp();\n                    MUTATION[key] = [beforeMutationTs, 0];\n                    hasOptimisticData = !isUndefined(optimisticData);\n                    rollbackData = cache.get(key);\n                    // Do optimistic data update.\n                    if (hasOptimisticData) {\n                        cache.set(key, optimisticData);\n                        broadcastState(cache, key, optimisticData);\n                    }\n                    if (isFunction(data)) {\n                        // `data` is a function, call it passing current cache value.\n                        try {\n                            data = data(cache.get(key));\n                        }\n                        catch (err) {\n                            // If it throws an error synchronously, we shouldn't update the cache.\n                            error = err;\n                        }\n                    }\n                    if (!(data && isFunction(data.then))) return [3 /*break*/, 2];\n                    return [4 /*yield*/, data.catch(function (err) {\n                            error = err;\n                        })\n                        // Check if other mutations have occurred since we've started this mutation.\n                        // If there's a race we don't update cache or broadcast the change,\n                        // just return the data.\n                    ];\n                case 1:\n                    // This means that the mutation is async, we need to check timestamps to\n                    // avoid race conditions.\n                    data = _c.sent();\n                    // Check if other mutations have occurred since we've started this mutation.\n                    // If there's a race we don't update cache or broadcast the change,\n                    // just return the data.\n                    if (beforeMutationTs !== MUTATION[key][0]) {\n                        if (error)\n                            throw error;\n                        return [2 /*return*/, data];\n                    }\n                    else if (error && hasOptimisticData && rollbackOnError) {\n                        // Rollback. Always populate the cache in this case but without\n                        // transforming the data.\n                        populateCache = true;\n                        data = rollbackData;\n                        cache.set(key, rollbackData);\n                    }\n                    _c.label = 2;\n                case 2:\n                    // If we should write back the cache after request.\n                    if (populateCache) {\n                        if (!error) {\n                            // Transform the result into data.\n                            if (isFunction(populateCache)) {\n                                data = populateCache(data, rollbackData);\n                            }\n                            // Only update cached data if there's no error. Data can be `undefined` here.\n                            cache.set(key, data);\n                        }\n                        // Always update or reset the error.\n                        cache.set(keyInfo, mergeObjects(cache.get(keyInfo), { error: error }));\n                    }\n                    // Reset the timestamp to mark the mutation has ended.\n                    MUTATION[key][1] = getTimestamp();\n                    return [4 /*yield*/, broadcastState(cache, key, data, error, UNDEFINED, revalidate, !!populateCache)\n                        // Throw error or return data\n                    ];\n                case 3:\n                    res = _c.sent();\n                    // Throw error or return data\n                    if (error)\n                        throw error;\n                    return [2 /*return*/, populateCache ? res : data];\n            }\n        });\n    });\n};\n\nvar revalidateAllKeys = function (revalidators, type) {\n    for (var key in revalidators) {\n        if (revalidators[key][0])\n            revalidators[key][0](type);\n    }\n};\nvar initCache = function (provider, options) {\n    // The global state for a specific provider will be used to deduplicate\n    // requests and store listeners. As well as a mutate function that bound to\n    // the cache.\n    // Provider's global state might be already initialized. Let's try to get the\n    // global state associated with the provider first.\n    if (!SWRGlobalState.has(provider)) {\n        var opts = mergeObjects(defaultConfigOptions, options);\n        // If there's no global state bound to the provider, create a new one with the\n        // new mutate function.\n        var EVENT_REVALIDATORS = {};\n        var mutate = internalMutate.bind(UNDEFINED, provider);\n        var unmount = noop;\n        // Update the state if it's new, or the provider has been extended.\n        SWRGlobalState.set(provider, [EVENT_REVALIDATORS, {}, {}, {}, mutate]);\n        // This is a new provider, we need to initialize it and setup DOM events\n        // listeners for `focus` and `reconnect` actions.\n        if (!IS_SERVER) {\n            // When listening to the native events for auto revalidations,\n            // we intentionally put a delay (setTimeout) here to make sure they are\n            // fired after immediate JavaScript executions, which can possibly be\n            // React's state updates.\n            // This avoids some unnecessary revalidations such as\n            // https://github.com/vercel/swr/issues/1680.\n            var releaseFocus_1 = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));\n            var releaseReconnect_1 = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));\n            unmount = function () {\n                releaseFocus_1 && releaseFocus_1();\n                releaseReconnect_1 && releaseReconnect_1();\n                // When un-mounting, we need to remove the cache provider from the state\n                // storage too because it's a side-effect. Otherwise when re-mounting we\n                // will not re-register those event listeners.\n                SWRGlobalState.delete(provider);\n            };\n        }\n        // We might want to inject an extra layer on top of `provider` in the future,\n        // such as key serialization, auto GC, etc.\n        // For now, it's just a `Map` interface without any modifications.\n        return [provider, mutate, unmount];\n    }\n    return [provider, SWRGlobalState.get(provider)[4]];\n};\n\n// error retry\nvar onErrorRetry = function (_, __, config, revalidate, opts) {\n    var maxRetryCount = config.errorRetryCount;\n    var currentRetryCount = opts.retryCount;\n    // Exponential backoff\n    var timeout = ~~((Math.random() + 0.5) *\n        (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;\n    if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) {\n        return;\n    }\n    setTimeout(revalidate, timeout, opts);\n};\n// Default cache provider\nvar _a = initCache(new Map()), cache = _a[0], mutate = _a[1];\n// Default config\nvar defaultConfig = mergeObjects({\n    // events\n    onLoadingSlow: noop,\n    onSuccess: noop,\n    onError: noop,\n    onErrorRetry: onErrorRetry,\n    onDiscarded: noop,\n    // switches\n    revalidateOnFocus: true,\n    revalidateOnReconnect: true,\n    revalidateIfStale: true,\n    shouldRetryOnError: true,\n    // timeouts\n    errorRetryInterval: slowConnection ? 10000 : 5000,\n    focusThrottleInterval: 5 * 1000,\n    dedupingInterval: 2 * 1000,\n    loadingTimeout: slowConnection ? 5000 : 3000,\n    // providers\n    compare: function (currentData, newData) {\n        return stableHash(currentData) == stableHash(newData);\n    },\n    isPaused: function () { return false; },\n    cache: cache,\n    mutate: mutate,\n    fallback: {}\n}, \n// use web preset by default\npreset);\n\nvar mergeConfigs = function (a, b) {\n    // Need to create a new object to avoid mutating the original here.\n    var v = mergeObjects(a, b);\n    // If two configs are provided, merge their `use` and `fallback` options.\n    if (b) {\n        var u1 = a.use, f1 = a.fallback;\n        var u2 = b.use, f2 = b.fallback;\n        if (u1 && u2) {\n            v.use = u1.concat(u2);\n        }\n        if (f1 && f2) {\n            v.fallback = mergeObjects(f1, f2);\n        }\n    }\n    return v;\n};\n\nvar SWRConfigContext = createContext({});\nvar SWRConfig$1 = function (props) {\n    var value = props.value;\n    // Extend parent context values and middleware.\n    var extendedConfig = mergeConfigs(useContext(SWRConfigContext), value);\n    // Should not use the inherited provider.\n    var provider = value && value.provider;\n    // Use a lazy initialized state to create the cache on first access.\n    var cacheContext = useState(function () {\n        return provider\n            ? initCache(provider(extendedConfig.cache || cache), value)\n            : UNDEFINED;\n    })[0];\n    // Override the cache if a new provider is given.\n    if (cacheContext) {\n        extendedConfig.cache = cacheContext[0];\n        extendedConfig.mutate = cacheContext[1];\n    }\n    // Unsubscribe events.\n    useIsomorphicLayoutEffect(function () { return (cacheContext ? cacheContext[2] : UNDEFINED); }, []);\n    return createElement(SWRConfigContext.Provider, mergeObjects(props, {\n        value: extendedConfig\n    }));\n};\n\n/**\n * An implementation of state with dependency-tracking.\n */\nvar useStateWithDeps = function (state, unmountedRef) {\n    var rerender = useState({})[1];\n    var stateRef = useRef(state);\n    // If a state property (data, error or isValidating) is accessed by the render\n    // function, we mark the property as a dependency so if it is updated again\n    // in the future, we trigger a rerender.\n    // This is also known as dependency-tracking.\n    var stateDependenciesRef = useRef({\n        data: false,\n        error: false,\n        isValidating: false\n    });\n    /**\n     * @param payload To change stateRef, pass the values explicitly to setState:\n     * @example\n     * ```js\n     * setState({\n     *   isValidating: false\n     *   data: newData // set data to newData\n     *   error: undefined // set error to undefined\n     * })\n     *\n     * setState({\n     *   isValidating: false\n     *   data: undefined // set data to undefined\n     *   error: err // set error to err\n     * })\n     * ```\n     */\n    var setState = useCallback(function (payload) {\n        var shouldRerender = false;\n        var currentState = stateRef.current;\n        for (var _ in payload) {\n            var k = _;\n            // If the property has changed, update the state and mark rerender as\n            // needed.\n            if (currentState[k] !== payload[k]) {\n                currentState[k] = payload[k];\n                // If the property is accessed by the component, a rerender should be\n                // triggered.\n                if (stateDependenciesRef.current[k]) {\n                    shouldRerender = true;\n                }\n            }\n        }\n        if (shouldRerender && !unmountedRef.current) {\n            rerender({});\n        }\n    }, \n    // config.suspense isn't allowed to change during the lifecycle\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    []);\n    // Always update the state reference.\n    useIsomorphicLayoutEffect(function () {\n        stateRef.current = state;\n    });\n    return [stateRef, stateDependenciesRef.current, setState];\n};\n\nvar normalize = function (args) {\n    return isFunction(args[1])\n        ? [args[0], args[1], args[2] || {}]\n        : [args[0], null, (args[1] === null ? args[2] : args[1]) || {}];\n};\n\nvar useSWRConfig = function () {\n    return mergeObjects(defaultConfig, useContext(SWRConfigContext));\n};\n\n// It's tricky to pass generic types as parameters, so we just directly override\n// the types here.\nvar withArgs = function (hook) {\n    return function useSWRArgs() {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        // Get the default and inherited configuration.\n        var fallbackConfig = useSWRConfig();\n        // Normalize arguments.\n        var _a = normalize(args), key = _a[0], fn = _a[1], _config = _a[2];\n        // Merge configurations.\n        var config = mergeConfigs(fallbackConfig, _config);\n        // Apply middleware\n        var next = hook;\n        var use = config.use;\n        if (use) {\n            for (var i = use.length; i-- > 0;) {\n                next = use[i](next);\n            }\n        }\n        return next(key, fn || config.fetcher, config);\n    };\n};\n\n// Add a callback function to a list of keyed callback functions and return\n// the unsubscribe function.\nvar subscribeCallback = function (key, callbacks, callback) {\n    var keyedRevalidators = callbacks[key] || (callbacks[key] = []);\n    keyedRevalidators.push(callback);\n    return function () {\n        var index = keyedRevalidators.indexOf(callback);\n        if (index >= 0) {\n            // O(1): faster than splice\n            keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];\n            keyedRevalidators.pop();\n        }\n    };\n};\n\nvar WITH_DEDUPE = { dedupe: true };\nvar useSWRHandler = function (_key, fetcher, config) {\n    var cache = config.cache, compare = config.compare, fallbackData = config.fallbackData, suspense = config.suspense, revalidateOnMount = config.revalidateOnMount, refreshInterval = config.refreshInterval, refreshWhenHidden = config.refreshWhenHidden, refreshWhenOffline = config.refreshWhenOffline;\n    var _a = SWRGlobalState.get(cache), EVENT_REVALIDATORS = _a[0], STATE_UPDATERS = _a[1], MUTATION = _a[2], FETCH = _a[3];\n    // `key` is the identifier of the SWR `data` state, `keyInfo` holds extra\n    // states such as `error` and `isValidating` inside,\n    // all of them are derived from `_key`.\n    // `fnArgs` is an array of arguments parsed from the key, which will be passed\n    // to the fetcher.\n    var _b = serialize(_key), key = _b[0], fnArgs = _b[1], keyInfo = _b[2];\n    // If it's the initial render of this hook.\n    var initialMountedRef = useRef(false);\n    // If the hook is unmounted already. This will be used to prevent some effects\n    // to be called after unmounting.\n    var unmountedRef = useRef(false);\n    // Refs to keep the key and config.\n    var keyRef = useRef(key);\n    var fetcherRef = useRef(fetcher);\n    var configRef = useRef(config);\n    var getConfig = function () { return configRef.current; };\n    var isActive = function () { return getConfig().isVisible() && getConfig().isOnline(); };\n    var patchFetchInfo = function (info) {\n        return cache.set(keyInfo, mergeObjects(cache.get(keyInfo), info));\n    };\n    // Get the current state that SWR should return.\n    var cached = cache.get(key);\n    var fallback = isUndefined(fallbackData)\n        ? config.fallback[key]\n        : fallbackData;\n    var data = isUndefined(cached) ? fallback : cached;\n    var info = cache.get(keyInfo) || {};\n    var error = info.error;\n    var isInitialMount = !initialMountedRef.current;\n    // - Suspense mode and there's stale data for the initial render.\n    // - Not suspense mode and there is no fallback data and `revalidateIfStale` is enabled.\n    // - `revalidateIfStale` is enabled but `data` is not defined.\n    var shouldRevalidate = function () {\n        // If `revalidateOnMount` is set, we take the value directly.\n        if (isInitialMount && !isUndefined(revalidateOnMount))\n            return revalidateOnMount;\n        // If it's paused, we skip revalidation.\n        if (getConfig().isPaused())\n            return false;\n        return suspense\n            ? // Under suspense mode, it will always fetch on render if there is no\n                // stale data so no need to revalidate immediately on mount again.\n                !isUndefined(data)\n            : // If there is no stale data, we need to revalidate on mount;\n                // If `revalidateIfStale` is set to true, we will always revalidate.\n                isUndefined(data) || config.revalidateIfStale;\n    };\n    // Resolve the current validating state.\n    var resolveValidating = function () {\n        if (!key || !fetcher)\n            return false;\n        if (info.isValidating)\n            return true;\n        // If it's not mounted yet and it should revalidate on mount, revalidate.\n        return isInitialMount && shouldRevalidate();\n    };\n    var isValidating = resolveValidating();\n    var _c = useStateWithDeps({\n        data: data,\n        error: error,\n        isValidating: isValidating\n    }, unmountedRef), stateRef = _c[0], stateDependencies = _c[1], setState = _c[2];\n    // The revalidation function is a carefully crafted wrapper of the original\n    // `fetcher`, to correctly handle the many edge cases.\n    var revalidate = useCallback(function (revalidateOpts) { return __awaiter(void 0, void 0, void 0, function () {\n        var currentFetcher, newData, startAt, loading, opts, shouldStartNewRequest, isCurrentKeyMounted, cleanupState, newState, finishRequestAndUpdateState, mutationInfo, err_1;\n        var _a;\n        return __generator(this, function (_b) {\n            switch (_b.label) {\n                case 0:\n                    currentFetcher = fetcherRef.current;\n                    if (!key ||\n                        !currentFetcher ||\n                        unmountedRef.current ||\n                        getConfig().isPaused()) {\n                        return [2 /*return*/, false];\n                    }\n                    loading = true;\n                    opts = revalidateOpts || {};\n                    shouldStartNewRequest = !FETCH[key] || !opts.dedupe;\n                    isCurrentKeyMounted = function () {\n                        return !unmountedRef.current &&\n                            key === keyRef.current &&\n                            initialMountedRef.current;\n                    };\n                    cleanupState = function () {\n                        // Check if it's still the same request before deleting.\n                        var requestInfo = FETCH[key];\n                        if (requestInfo && requestInfo[1] === startAt) {\n                            delete FETCH[key];\n                        }\n                    };\n                    newState = { isValidating: false };\n                    finishRequestAndUpdateState = function () {\n                        patchFetchInfo({ isValidating: false });\n                        // We can only set state if it's safe (still mounted with the same key).\n                        if (isCurrentKeyMounted()) {\n                            setState(newState);\n                        }\n                    };\n                    // Start fetching. Change the `isValidating` state, update the cache.\n                    patchFetchInfo({\n                        isValidating: true\n                    });\n                    setState({ isValidating: true });\n                    _b.label = 1;\n                case 1:\n                    _b.trys.push([1, 3, , 4]);\n                    if (shouldStartNewRequest) {\n                        // Tell all other hooks to change the `isValidating` state.\n                        broadcastState(cache, key, stateRef.current.data, stateRef.current.error, true);\n                        // If no cache being rendered currently (it shows a blank page),\n                        // we trigger the loading slow event.\n                        if (config.loadingTimeout && !cache.get(key)) {\n                            setTimeout(function () {\n                                if (loading && isCurrentKeyMounted()) {\n                                    getConfig().onLoadingSlow(key, config);\n                                }\n                            }, config.loadingTimeout);\n                        }\n                        // Start the request and save the timestamp.\n                        FETCH[key] = [currentFetcher.apply(void 0, fnArgs), getTimestamp()];\n                    }\n                    _a = FETCH[key], newData = _a[0], startAt = _a[1];\n                    return [4 /*yield*/, newData];\n                case 2:\n                    newData = _b.sent();\n                    if (shouldStartNewRequest) {\n                        // If the request isn't interrupted, clean it up after the\n                        // deduplication interval.\n                        setTimeout(cleanupState, config.dedupingInterval);\n                    }\n                    // If there're other ongoing request(s), started after the current one,\n                    // we need to ignore the current one to avoid possible race conditions:\n                    //   req1------------------>res1        (current one)\n                    //        req2---------------->res2\n                    // the request that fired later will always be kept.\n                    // The timestamp maybe be `undefined` or a number\n                    if (!FETCH[key] || FETCH[key][1] !== startAt) {\n                        if (shouldStartNewRequest) {\n                            if (isCurrentKeyMounted()) {\n                                getConfig().onDiscarded(key);\n                            }\n                        }\n                        return [2 /*return*/, false];\n                    }\n                    // Clear error.\n                    patchFetchInfo({\n                        error: UNDEFINED\n                    });\n                    newState.error = UNDEFINED;\n                    mutationInfo = MUTATION[key];\n                    if (!isUndefined(mutationInfo) &&\n                        // case 1\n                        (startAt <= mutationInfo[0] ||\n                            // case 2\n                            startAt <= mutationInfo[1] ||\n                            // case 3\n                            mutationInfo[1] === 0)) {\n                        finishRequestAndUpdateState();\n                        if (shouldStartNewRequest) {\n                            if (isCurrentKeyMounted()) {\n                                getConfig().onDiscarded(key);\n                            }\n                        }\n                        return [2 /*return*/, false];\n                    }\n                    // Deep compare with latest state to avoid extra re-renders.\n                    // For local state, compare and assign.\n                    if (!compare(stateRef.current.data, newData)) {\n                        newState.data = newData;\n                    }\n                    else {\n                        // data and newData are deeply equal\n                        // it should be safe to broadcast the stale data\n                        newState.data = stateRef.current.data;\n                        // At the end of this function, `brocastState` invokes the `onStateUpdate` function,\n                        // which takes care of avoiding the re-render\n                    }\n                    // For global state, it's possible that the key has changed.\n                    // https://github.com/vercel/swr/pull/1058\n                    if (!compare(cache.get(key), newData)) {\n                        cache.set(key, newData);\n                    }\n                    // Trigger the successful callback if it's the original request.\n                    if (shouldStartNewRequest) {\n                        if (isCurrentKeyMounted()) {\n                            getConfig().onSuccess(newData, key, config);\n                        }\n                    }\n                    return [3 /*break*/, 4];\n                case 3:\n                    err_1 = _b.sent();\n                    cleanupState();\n                    // Not paused, we continue handling the error. Otherwise discard it.\n                    if (!getConfig().isPaused()) {\n                        // Get a new error, don't use deep comparison for errors.\n                        patchFetchInfo({ error: err_1 });\n                        newState.error = err_1;\n                        // Error event and retry logic. Only for the actual request, not\n                        // deduped ones.\n                        if (shouldStartNewRequest && isCurrentKeyMounted()) {\n                            getConfig().onError(err_1, key, config);\n                            if ((typeof config.shouldRetryOnError === 'boolean' &&\n                                config.shouldRetryOnError) ||\n                                (isFunction(config.shouldRetryOnError) &&\n                                    config.shouldRetryOnError(err_1))) {\n                                // When retrying, dedupe is always enabled\n                                if (isActive()) {\n                                    // If it's active, stop. It will auto revalidate when refocusing\n                                    // or reconnecting.\n                                    getConfig().onErrorRetry(err_1, key, config, revalidate, {\n                                        retryCount: (opts.retryCount || 0) + 1,\n                                        dedupe: true\n                                    });\n                                }\n                            }\n                        }\n                    }\n                    return [3 /*break*/, 4];\n                case 4:\n                    // Mark loading as stopped.\n                    loading = false;\n                    // Update the current hook's state.\n                    finishRequestAndUpdateState();\n                    // Here is the source of the request, need to tell all other hooks to\n                    // update their states.\n                    if (isCurrentKeyMounted() && shouldStartNewRequest) {\n                        broadcastState(cache, key, newState.data, newState.error, false);\n                    }\n                    return [2 /*return*/, true];\n            }\n        });\n    }); }, \n    // `setState` is immutable, and `eventsCallback`, `fnArgs`, `keyInfo`,\n    // and `keyValidating` are depending on `key`, so we can exclude them from\n    // the deps array.\n    //\n    // FIXME:\n    // `fn` and `config` might be changed during the lifecycle,\n    // but they might be changed every render like this.\n    // `useSWR('key', () => fetch('/api/'), { suspense: true })`\n    // So we omit the values from the deps array\n    // even though it might cause unexpected behaviors.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [key]);\n    // Similar to the global mutate, but bound to the current cache and key.\n    // `cache` isn't allowed to change during the lifecycle.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    var boundMutate = useCallback(\n    // By using `bind` we don't need to modify the size of the rest arguments.\n    // Due to https://github.com/microsoft/TypeScript/issues/37181, we have to\n    // cast it to any for now.\n    internalMutate.bind(UNDEFINED, cache, function () { return keyRef.current; }), \n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    []);\n    // Always update fetcher and config refs.\n    useIsomorphicLayoutEffect(function () {\n        fetcherRef.current = fetcher;\n        configRef.current = config;\n    });\n    // After mounted or key changed.\n    useIsomorphicLayoutEffect(function () {\n        if (!key)\n            return;\n        var keyChanged = key !== keyRef.current;\n        var softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);\n        // Expose state updater to global event listeners. So we can update hook's\n        // internal state from the outside.\n        var onStateUpdate = function (updatedData, updatedError, updatedIsValidating) {\n            setState(mergeObjects({\n                error: updatedError,\n                isValidating: updatedIsValidating\n            }, \n            // Since `setState` only shallowly compares states, we do a deep\n            // comparison here.\n            compare(stateRef.current.data, updatedData)\n                ? UNDEFINED\n                : {\n                    data: updatedData\n                }));\n        };\n        // Expose revalidators to global event listeners. So we can trigger\n        // revalidation from the outside.\n        var nextFocusRevalidatedAt = 0;\n        var onRevalidate = function (type) {\n            if (type == FOCUS_EVENT) {\n                var now = Date.now();\n                if (getConfig().revalidateOnFocus &&\n                    now > nextFocusRevalidatedAt &&\n                    isActive()) {\n                    nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;\n                    softRevalidate();\n                }\n            }\n            else if (type == RECONNECT_EVENT) {\n                if (getConfig().revalidateOnReconnect && isActive()) {\n                    softRevalidate();\n                }\n            }\n            else if (type == MUTATE_EVENT) {\n                return revalidate();\n            }\n            return;\n        };\n        var unsubUpdate = subscribeCallback(key, STATE_UPDATERS, onStateUpdate);\n        var unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);\n        // Mark the component as mounted and update corresponding refs.\n        unmountedRef.current = false;\n        keyRef.current = key;\n        initialMountedRef.current = true;\n        // When `key` updates, reset the state to the initial value\n        // and trigger a rerender if necessary.\n        if (keyChanged) {\n            setState({\n                data: data,\n                error: error,\n                isValidating: isValidating\n            });\n        }\n        // Trigger a revalidation.\n        if (shouldRevalidate()) {\n            if (isUndefined(data) || IS_SERVER) {\n                // Revalidate immediately.\n                softRevalidate();\n            }\n            else {\n                // Delay the revalidate if we have data to return so we won't block\n                // rendering.\n                rAF(softRevalidate);\n            }\n        }\n        return function () {\n            // Mark it as unmounted.\n            unmountedRef.current = true;\n            unsubUpdate();\n            unsubEvents();\n        };\n    }, [key, revalidate]);\n    // Polling\n    useIsomorphicLayoutEffect(function () {\n        var timer;\n        function next() {\n            // Use the passed interval\n            // ...or invoke the function with the updated data to get the interval\n            var interval = isFunction(refreshInterval)\n                ? refreshInterval(data)\n                : refreshInterval;\n            // We only start next interval if `refreshInterval` is not 0, and:\n            // - `force` is true, which is the start of polling\n            // - or `timer` is not 0, which means the effect wasn't canceled\n            if (interval && timer !== -1) {\n                timer = setTimeout(execute, interval);\n            }\n        }\n        function execute() {\n            // Check if it's OK to execute:\n            // Only revalidate when the page is visible, online and not errored.\n            if (!stateRef.current.error &&\n                (refreshWhenHidden || getConfig().isVisible()) &&\n                (refreshWhenOffline || getConfig().isOnline())) {\n                revalidate(WITH_DEDUPE).then(next);\n            }\n            else {\n                // Schedule next interval to check again.\n                next();\n            }\n        }\n        next();\n        return function () {\n            if (timer) {\n                clearTimeout(timer);\n                timer = -1;\n            }\n        };\n    }, [refreshInterval, refreshWhenHidden, refreshWhenOffline, revalidate]);\n    // Display debug info in React DevTools.\n    useDebugValue(data);\n    // In Suspense mode, we can't return the empty `data` state.\n    // If there is `error`, the `error` needs to be thrown to the error boundary.\n    // If there is no `error`, the `revalidation` promise needs to be thrown to\n    // the suspense boundary.\n    if (suspense && isUndefined(data) && key) {\n        // Always update fetcher and config refs even with the Suspense mode.\n        fetcherRef.current = fetcher;\n        configRef.current = config;\n        unmountedRef.current = false;\n        throw isUndefined(error) ? revalidate(WITH_DEDUPE) : error;\n    }\n    return {\n        mutate: boundMutate,\n        get data() {\n            stateDependencies.data = true;\n            return data;\n        },\n        get error() {\n            stateDependencies.error = true;\n            return error;\n        },\n        get isValidating() {\n            stateDependencies.isValidating = true;\n            return isValidating;\n        }\n    };\n};\nvar SWRConfig = OBJECT.defineProperty(SWRConfig$1, 'default', {\n    value: defaultConfig\n});\nvar unstable_serialize = function (key) { return serialize(key)[0]; };\nvar useSWR = withArgs(useSWRHandler);\n\n// useSWR\n\nexport { SWRConfig, useSWR as default, mutate, unstable_serialize, useSWRConfig };\n","import { useEffect, useLayoutEffect, useState, useRef, useCallback } from 'react';\nimport useSWR from 'swr';\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nfunction __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\n\nvar noop = function () { };\n// Using noop() as the undefined value as undefined can possibly be replaced\n// by something else.  Prettier ignore and extra parentheses are necessary here\n// to ensure that tsc doesn't remove the __NOINLINE__ comment.\n// prettier-ignore\nvar UNDEFINED = ( /*#__NOINLINE__*/noop());\nvar OBJECT = Object;\nvar isUndefined = function (v) { return v === UNDEFINED; };\nvar isFunction = function (v) { return typeof v == 'function'; };\nvar STR_UNDEFINED = 'undefined';\n// NOTE: Use function to guarantee it's re-evaluated between jsdom and node runtime for tests.\nvar hasWindow = function () { return typeof window != STR_UNDEFINED; };\n\nvar IS_SERVER = !hasWindow() || 'Deno' in window;\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\nvar useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;\n\n// use WeakMap to store the object->key mapping\n// so the objects can be garbage collected.\n// WeakMap uses a hashtable under the hood, so the lookup\n// complexity is almost O(1).\nvar table = new WeakMap();\n// counter of the key\nvar counter = 0;\n// A stable hash implementation that supports:\n// - Fast and ensures unique hash properties\n// - Handles unserializable values\n// - Handles object key ordering\n// - Generates short results\n//\n// This is not a serialization function, and the result is not guaranteed to be\n// parsible.\nvar stableHash = function (arg) {\n    var type = typeof arg;\n    var constructor = arg && arg.constructor;\n    var isDate = constructor == Date;\n    var result;\n    var index;\n    if (OBJECT(arg) === arg && !isDate && constructor != RegExp) {\n        // Object/function, not null/date/regexp. Use WeakMap to store the id first.\n        // If it's already hashed, directly return the result.\n        result = table.get(arg);\n        if (result)\n            return result;\n        // Store the hash first for circular reference detection before entering the\n        // recursive `stableHash` calls.\n        // For other objects like set and map, we use this id directly as the hash.\n        result = ++counter + '~';\n        table.set(arg, result);\n        if (constructor == Array) {\n            // Array.\n            result = '@';\n            for (index = 0; index < arg.length; index++) {\n                result += stableHash(arg[index]) + ',';\n            }\n            table.set(arg, result);\n        }\n        if (constructor == OBJECT) {\n            // Object, sort keys.\n            result = '#';\n            var keys = OBJECT.keys(arg).sort();\n            while (!isUndefined((index = keys.pop()))) {\n                if (!isUndefined(arg[index])) {\n                    result += index + ':' + stableHash(arg[index]) + ',';\n                }\n            }\n            table.set(arg, result);\n        }\n    }\n    else {\n        result = isDate\n            ? arg.toJSON()\n            : type == 'symbol'\n                ? arg.toString()\n                : type == 'string'\n                    ? JSON.stringify(arg)\n                    : '' + arg;\n    }\n    return result;\n};\n\nvar serialize = function (key) {\n    if (isFunction(key)) {\n        try {\n            key = key();\n        }\n        catch (err) {\n            // dependencies not ready\n            key = '';\n        }\n    }\n    var args = [].concat(key);\n    // If key is not falsy, or not an empty array, hash it.\n    key =\n        typeof key == 'string'\n            ? key\n            : (Array.isArray(key) ? key.length : key)\n                ? stableHash(key)\n                : '';\n    var infoKey = key ? '$swr$' + key : '';\n    return [key, args, infoKey];\n};\n\nvar normalize = function (args) {\n    return isFunction(args[1])\n        ? [args[0], args[1], args[2] || {}]\n        : [args[0], null, (args[1] === null ? args[2] : args[1]) || {}];\n};\n\n// Create a custom hook with a middleware\nvar withMiddleware = function (useSWR, middleware) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var _a = normalize(args), key = _a[0], fn = _a[1], config = _a[2];\n        var uses = (config.use || []).concat(middleware);\n        return useSWR(key, fn, __assign(__assign({}, config), { use: uses }));\n    };\n};\n\n// We have to several type castings here because `useSWRInfinite` is a special\nvar INFINITE_PREFIX = '$inf$';\nvar getFirstPageKey = function (getKey) {\n    return serialize(getKey ? getKey(0, null) : null)[0];\n};\nvar unstable_serialize = function (getKey) {\n    return INFINITE_PREFIX + getFirstPageKey(getKey);\n};\nvar infinite = (function (useSWRNext) {\n    return function (getKey, fn, config) {\n        var rerender = useState({})[1];\n        var didMountRef = useRef(false);\n        var dataRef = useRef();\n        var cache = config.cache, _a = config.initialSize, initialSize = _a === void 0 ? 1 : _a, _b = config.revalidateAll, revalidateAll = _b === void 0 ? false : _b, _c = config.persistSize, persistSize = _c === void 0 ? false : _c, _d = config.revalidateFirstPage, revalidateFirstPage = _d === void 0 ? true : _d, _e = config.revalidateOnMount, revalidateOnMount = _e === void 0 ? false : _e;\n        // The serialized key of the first page.\n        var firstPageKey = null;\n        try {\n            firstPageKey = getFirstPageKey(getKey);\n        }\n        catch (err) {\n            // not ready\n        }\n        // We use cache to pass extra info (context) to fetcher so it can be globally\n        // shared. The key of the context data is based on the first page key.\n        var contextCacheKey = null;\n        // Page size is also cached to share the page data between hooks with the\n        // same key.\n        var pageSizeCacheKey = null;\n        if (firstPageKey) {\n            contextCacheKey = '$ctx$' + firstPageKey;\n            pageSizeCacheKey = '$len$' + firstPageKey;\n        }\n        var resolvePageSize = useCallback(function () {\n            var cachedPageSize = cache.get(pageSizeCacheKey);\n            return isUndefined(cachedPageSize) ? initialSize : cachedPageSize;\n            // `cache` isn't allowed to change during the lifecycle\n            // eslint-disable-next-line react-hooks/exhaustive-deps\n        }, [pageSizeCacheKey, initialSize]);\n        // keep the last page size to restore it with the persistSize option\n        var lastPageSizeRef = useRef(resolvePageSize());\n        // When the page key changes, we reset the page size if it's not persisted\n        useIsomorphicLayoutEffect(function () {\n            if (!didMountRef.current) {\n                didMountRef.current = true;\n                return;\n            }\n            if (firstPageKey) {\n                // If the key has been changed, we keep the current page size if persistSize is enabled\n                cache.set(pageSizeCacheKey, persistSize ? lastPageSizeRef.current : initialSize);\n            }\n            // `initialSize` isn't allowed to change during the lifecycle\n            // eslint-disable-next-line react-hooks/exhaustive-deps\n        }, [firstPageKey]);\n        // Needs to check didMountRef during mounting, not in the fetcher\n        var shouldRevalidateOnMount = revalidateOnMount && !didMountRef.current;\n        // Actual SWR hook to load all pages in one fetcher.\n        var swr = useSWRNext(firstPageKey ? INFINITE_PREFIX + firstPageKey : null, function () { return __awaiter(void 0, void 0, void 0, function () {\n            var _a, forceRevalidateAll, originalData, data, pageSize, previousPageData, i, _b, pageKey, pageArgs, pageData, shouldFetchPage;\n            return __generator(this, function (_c) {\n                switch (_c.label) {\n                    case 0:\n                        _a = cache.get(contextCacheKey) || [], forceRevalidateAll = _a[0], originalData = _a[1];\n                        data = [];\n                        pageSize = resolvePageSize();\n                        previousPageData = null;\n                        i = 0;\n                        _c.label = 1;\n                    case 1:\n                        if (!(i < pageSize)) return [3 /*break*/, 5];\n                        _b = serialize(getKey(i, previousPageData)), pageKey = _b[0], pageArgs = _b[1];\n                        if (!pageKey) {\n                            // `pageKey` is falsy, stop fetching new pages.\n                            return [3 /*break*/, 5];\n                        }\n                        pageData = cache.get(pageKey);\n                        shouldFetchPage = revalidateAll ||\n                            forceRevalidateAll ||\n                            isUndefined(pageData) ||\n                            (revalidateFirstPage && !i && !isUndefined(dataRef.current)) ||\n                            shouldRevalidateOnMount ||\n                            (originalData &&\n                                !isUndefined(originalData[i]) &&\n                                !config.compare(originalData[i], pageData));\n                        if (!(fn && shouldFetchPage)) return [3 /*break*/, 3];\n                        return [4 /*yield*/, fn.apply(void 0, pageArgs)];\n                    case 2:\n                        pageData = _c.sent();\n                        cache.set(pageKey, pageData);\n                        _c.label = 3;\n                    case 3:\n                        data.push(pageData);\n                        previousPageData = pageData;\n                        _c.label = 4;\n                    case 4:\n                        ++i;\n                        return [3 /*break*/, 1];\n                    case 5:\n                        // once we executed the data fetching based on the context, clear the context\n                        cache.delete(contextCacheKey);\n                        // return the data\n                        return [2 /*return*/, data];\n                }\n            });\n        }); }, config);\n        // update dataRef\n        useIsomorphicLayoutEffect(function () {\n            dataRef.current = swr.data;\n        }, [swr.data]);\n        var mutate = useCallback(function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            var data = args[0];\n            // Default to true.\n            var shouldRevalidate = args[1] !== false;\n            // It is possible that the key is still falsy.\n            if (!contextCacheKey)\n                return;\n            if (shouldRevalidate) {\n                if (!isUndefined(data)) {\n                    // We only revalidate the pages that are changed\n                    var originalData = dataRef.current;\n                    cache.set(contextCacheKey, [false, originalData]);\n                }\n                else {\n                    // Calling `mutate()`, we revalidate all pages\n                    cache.set(contextCacheKey, [true]);\n                }\n            }\n            return args.length ? swr.mutate(data, shouldRevalidate) : swr.mutate();\n        }, \n        // swr.mutate is always the same reference\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        [contextCacheKey]);\n        // Function to load pages data from the cache based on the page size.\n        var resolvePagesFromCache = function (pageSize) {\n            // return an array of page data\n            var data = [];\n            var previousPageData = null;\n            for (var i = 0; i < pageSize; ++i) {\n                var pageKey = serialize(getKey(i, previousPageData))[0];\n                // Get the cached page data.\n                var pageData = pageKey ? cache.get(pageKey) : UNDEFINED;\n                // Return the current data if we can't get it from the cache.\n                if (isUndefined(pageData))\n                    return dataRef.current;\n                data.push(pageData);\n                previousPageData = pageData;\n            }\n            // Return the data\n            return data;\n        };\n        // Extend the SWR API\n        var setSize = useCallback(function (arg) {\n            // It is possible that the key is still falsy.\n            if (!pageSizeCacheKey)\n                return;\n            var size;\n            if (isFunction(arg)) {\n                size = arg(resolvePageSize());\n            }\n            else if (typeof arg == 'number') {\n                size = arg;\n            }\n            if (typeof size != 'number')\n                return;\n            cache.set(pageSizeCacheKey, size);\n            lastPageSizeRef.current = size;\n            rerender({});\n            return mutate(resolvePagesFromCache(size));\n        }, \n        // `cache` and `rerender` isn't allowed to change during the lifecycle\n        // eslint-disable-next-line react-hooks/exhaustive-deps\n        [pageSizeCacheKey, resolvePageSize, mutate]);\n        // Use getter functions to avoid unnecessary re-renders caused by triggering\n        // all the getters of the returned swr object.\n        return {\n            size: resolvePageSize(),\n            setSize: setSize,\n            mutate: mutate,\n            get error() {\n                return swr.error;\n            },\n            get data() {\n                return swr.data;\n            },\n            get isValidating() {\n                return swr.isValidating;\n            }\n        };\n    };\n});\nvar index = withMiddleware(useSWR, infinite);\n\nexport { index as default, infinite, unstable_serialize };\n"],"names":["module","exports","cssWithMappingToString","list","toString","this","map","item","content","concat","join","i","modules","mediaQuery","dedupe","alreadyImportedModules","length","id","_i","push","_arrayLikeToArray","arr","len","arr2","Array","_item","isArray","_arrayWithHoles","Symbol","iterator","_s","_e","_arr","_n","_d","call","next","done","value","err","_iterableToArrayLimit","o","minLen","n","Object","prototype","slice","constructor","name","from","test","_unsupportedIterableToArray","TypeError","_nonIterableRest","cssMapping","btoa","base64","unescape","encodeURIComponent","JSON","stringify","data","sourceMapping","sourceURLs","sources","source","sourceRoot","stylesInDOM","getIndexByIdentifier","identifier","result","modulesToDom","options","idCountMap","identifiers","base","count","indexByIdentifier","obj","css","media","sourceMap","supports","layer","references","updater","addElementStyle","byIndex","splice","api","domAPI","update","newObj","remove","lastIdentifiers","newList","index","newLastIdentifiers","_index","memo","insert","style","target","styleTarget","document","querySelector","window","HTMLIFrameElement","contentDocument","head","e","getTarget","Error","appendChild","element","createElement","setAttributes","attributes","styleElement","nonce","setAttribute","insertStyleElement","needLayer","styleTagTransform","apply","parentNode","removeChild","removeStyleElement","styleSheet","cssText","firstChild","createTextNode","type","global","freeSelf","self","Function","reWhitespace","reTrimStart","string","charAt","replace","objectProto","hasOwnProperty","nativeObjectToString","symToStringTag","undefined","isOwn","tag","unmasked","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","isBinary","nativeMax","Math","max","nativeMin","min","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","args","thisArg","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","clearTimeout","cancel","flush","__awaiter","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","rejected","then","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","v","op","pop","hook","noop","UNDEFINED","OBJECT","isUndefined","isFunction","mergeObjects","a","b","assign","STR_UNDEFINED","hasWindow","table","WeakMap","counter","stableHash","arg","isDate","Date","RegExp","toJSON","get","set","keys","sort","online","hasWin","hasDoc","onWindowEvent","addEventListener","bind","onDocumentEvent","offWindowEvent","removeEventListener","offDocumentEvent","preset","isOnline","isVisible","visibilityState","defaultConfigOptions","initFocus","callback","initReconnect","onOnline","onOffline","IS_SERVER","useIsomorphicLayoutEffect","useEffect","useLayoutEffect","navigatorConnection","navigator","connection","slowConnection","includes","effectiveType","saveData","serialize","key","SWRGlobalState","broadcastState","cache","error","isValidating","revalidate","broadcast","_a","EVENT_REVALIDATORS","STATE_UPDATERS","FETCH","revalidators","updaters","__timestamp","getTimestamp","internalMutate","_key","_data","_opts","populateCache","rollbackOnError","optimisticData","keyInfo","_b","MUTATION","beforeMutationTs","hasOptimisticData","rollbackData","res","_c","catch","revalidateAllKeys","initCache","provider","has","opts","mutate","unmount","releaseFocus_1","releaseReconnect_1","delete","Map","defaultConfig","onLoadingSlow","onSuccess","onError","onErrorRetry","__","config","maxRetryCount","errorRetryCount","currentRetryCount","retryCount","timeout","random","errorRetryInterval","onDiscarded","revalidateOnFocus","revalidateOnReconnect","revalidateIfStale","shouldRetryOnError","focusThrottleInterval","dedupingInterval","loadingTimeout","compare","currentData","newData","isPaused","fallback","mergeConfigs","u1","use","f1","u2","f2","SWRConfigContext","createContext","normalize","useSWRConfig","useContext","subscribeCallback","callbacks","keyedRevalidators","indexOf","WITH_DEDUPE","useSWR","defineProperty","props","extendedConfig","cacheContext","useState","Provider","fetcher","fallbackData","suspense","revalidateOnMount","refreshInterval","refreshWhenHidden","refreshWhenOffline","fnArgs","initialMountedRef","useRef","unmountedRef","keyRef","fetcherRef","configRef","getConfig","current","isActive","patchFetchInfo","info","cached","isInitialMount","shouldRevalidate","state","rerender","stateRef","stateDependenciesRef","setState","useCallback","payload","shouldRerender","currentState","k","useStateWithDeps","stateDependencies","revalidateOpts","currentFetcher","startAt","loading","shouldStartNewRequest","isCurrentKeyMounted","cleanupState","newState","finishRequestAndUpdateState","mutationInfo","err_1","requestInfo","boundMutate","keyChanged","softRevalidate","nextFocusRevalidatedAt","unsubUpdate","updatedData","updatedError","updatedIsValidating","unsubEvents","now","timer","interval","execute","useDebugValue","fallbackConfig","fn","_config","__assign","s","p","middleware","uses","withMiddleware","useSWRNext","getKey","didMountRef","dataRef","initialSize","revalidateAll","persistSize","revalidateFirstPage","firstPageKey","getFirstPageKey","contextCacheKey","pageSizeCacheKey","resolvePageSize","cachedPageSize","lastPageSizeRef","shouldRevalidateOnMount","swr","forceRevalidateAll","originalData","pageSize","previousPageData","pageKey","pageArgs","pageData","shouldFetchPage","setSize","size","resolvePagesFromCache"],"sourceRoot":""}