redux-astroglide 0.1.20 → 0.1.21

package/dist/index.umd.js

@@ -1,9 +1,63 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react-redux'), require('react')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react-redux', 'react'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide"] = {}, global.reactRedux, global.react));
-})(this, (function (exports, reactRedux, react) { 'use strict';
-
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react-redux')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react-redux'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["redux-astroglide"] = {}, global.reactRedux));
+})(this, (function (exports, reactRedux) { 'use strict';
+
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithoutHoles(r) {
+    if (Array.isArray(r)) return _arrayLikeToArray(r);
+  }
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _construct(t, e, r) {
+    if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+    var o = [null];
+    o.push.apply(o, e);
+    var p = new (t.bind.apply(t, o))();
+    return r && _setPrototypeOf(p, r.prototype), p;
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  function _defineProperty$1(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
+  function _isNativeReflectConstruct() {
+    try {
+      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    } catch (t) {}
+    return (_isNativeReflectConstruct = function () {
+      return !!t;
+    })();
+  }
+  function _iterableToArray(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  }
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _objectDestructuringEmpty(t) {
+    if (null == t) throw new TypeError("Cannot destructure " + t);
+  }
   function ownKeys$1(e, r) {
     var t = Object.keys(e);
     if (Object.getOwnPropertySymbols) {
@@ -25,152 +79,63 @@
     }
     return e;
   }
-  function _typeof$1(o) {
-    "@babel/helpers - typeof";
-
-    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
-      return typeof o;
-    } : function (o) {
-      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-    }, _typeof$1(o);
-  }
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-  function _defineProperties(target, props) {
-    for (var i = 0; i < props.length; i++) {
-      var descriptor = props[i];
-      descriptor.enumerable = descriptor.enumerable || false;
-      descriptor.configurable = true;
-      if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, _toPropertyKey$1(descriptor.key), descriptor);
-    }
-  }
-  function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    Object.defineProperty(Constructor, "prototype", {
-      writable: false
-    });
-    return Constructor;
-  }
-  function _defineProperty$1(obj, key, value) {
-    key = _toPropertyKey$1(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
-    return _setPrototypeOf(o, p);
-  }
-  function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-      return true;
-    } catch (e) {
-      return false;
+  function _objectWithoutProperties(e, t) {
+    if (null == e) return {};
+    var o,
+      r,
+      i = _objectWithoutPropertiesLoose(e, t);
+    if (Object.getOwnPropertySymbols) {
+      var n = Object.getOwnPropertySymbols(e);
+      for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
     }
+    return i;
   }
-  function _construct(Parent, args, Class) {
-    if (_isNativeReflectConstruct()) {
-      _construct = Reflect.construct.bind();
-    } else {
-      _construct = function _construct(Parent, args, Class) {
-        var a = [null];
-        a.push.apply(a, args);
-        var Constructor = Function.bind.apply(Parent, a);
-        var instance = new Constructor();
-        if (Class) _setPrototypeOf(instance, Class.prototype);
-        return instance;
-      };
+  function _objectWithoutPropertiesLoose(r, e) {
+    if (null == r) return {};
+    var t = {};
+    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+      if (-1 !== e.indexOf(n)) continue;
+      t[n] = r[n];
     }
-    return _construct.apply(null, arguments);
+    return t;
   }
-  function _objectDestructuringEmpty(obj) {
-    if (obj == null) throw new TypeError("Cannot destructure " + obj);
+  function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, _setPrototypeOf(t, e);
   }
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
-    }
-    return target;
+  function _toConsumableArray(r) {
+    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
   }
-  function _objectWithoutProperties(source, excluded) {
-    if (source == null) return {};
-    var target = _objectWithoutPropertiesLoose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-      for (i = 0; i < sourceSymbolKeys.length; i++) {
-        key = sourceSymbolKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
-      }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    return target;
-  }
-  function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+    return ("string" === r ? String : Number)(t);
   }
-  function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
   }
-  function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-  }
-  function _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);
-  }
-  function _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;
-  }
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  function _typeof$1(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof$1(o);
   }
-  function _toPrimitive$1(input, hint) {
-    if (typeof input !== "object" || input === null) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== undefined) {
-      var res = prim.call(input, hint || "default");
-      if (typeof res !== "object") return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
     }
-    return (hint === "string" ? String : Number)(input);
-  }
-  function _toPropertyKey$1(arg) {
-    var key = _toPrimitive$1(arg, "string");
-    return typeof key === "symbol" ? key : String(key);
   }
 
   function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e<r;e++)t[e-1]=arguments[e];if("production"!==process.env.NODE_ENV){var i=Y[n],o=i?"function"==typeof i?i.apply(null,t):i:"unknown error nr: "+n;throw Error("[Immer] "+o)}throw Error("[Immer] minified error nr: "+n+(t.length?" "+t.map((function(n){return "'"+n+"'"})).join(","):"")+". Find the full error at: https://bit.ly/3cXEKWf")}function r(n){return !!n&&!!n[Q]}function t(n){var r;return !!n&&(function(n){if(!n||"object"!=typeof n)return !1;var r=Object.getPrototypeOf(n);if(null===r)return !0;var t=Object.hasOwnProperty.call(r,"constructor")&&r.constructor;return t===Object||"function"==typeof t&&Function.toString.call(t)===Z}(n)||Array.isArray(n)||!!n[L]||!!(null===(r=n.constructor)||void 0===r?void 0:r[L])||s(n)||v(n))}function i(n,r,t){void 0===t&&(t=!1),0===o(n)?(t?Object.keys:nn)(n).forEach((function(e){t&&"symbol"==typeof e||r(e,n[e],n);})):n.forEach((function(t,e){return r(e,t,n)}));}function o(n){var r=n[Q];return r?r.i>3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t;}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e<t.length;e++){var i=t[e],o=r[i];!1===o.writable&&(o.writable=!0,o.configurable=!0),(o.get||o.set)&&(r[i]={configurable:!0,writable:!0,enumerable:o.enumerable,value:n[i]});}return Object.create(Object.getPrototypeOf(n),r)}function d(n,e){return void 0===e&&(e=!1),y(n)||r(n)||!t(n)||(o(n)>1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,!0)}),!0)),n}function h(){n(2);}function y(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function m(n,r){tn[n]||(tn[n]=r);}function _(){return "production"===process.env.NODE_ENV||U||n(0),U}function j(n,r){r&&(b("Patches"),n.u=[],n.s=[],n.v=r);}function g(n){O(n),n.p.forEach(S),n.p=null;}function O(n){n===U&&(U=n.l);}function w(n){return U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.g=!0;}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.O||b("ES5").S(e,r,o),o?(i[Q].P&&(g(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b("Patches").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),g(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),!0),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o,u=o,a=!1;3===e.i&&(u=new Set(o),o.clear(),a=!0),i(u,(function(r,i){return A(n,e,o,r,i,t,a)})),x(n,o,!1),t&&n.u&&b("Patches").N(e,t,n.u,n.s);}return e.o}function A(e,i,o,a,c,s,v){if("production"!==process.env.NODE_ENV&&c===o&&n(5),r(c)){var p=M(e,c,s&&i&&3!==i.i&&!u(i.R,a)?s.concat(a):void 0);if(f(o,a,p),!r(p))return;e.m=!1;}else v&&o.add(c);if(t(c)&&!y(c)){if(!e.h.D&&e._<1)return;M(e,c),i&&i.A.l||x(e,c);}}function x(n,r,t){void 0===t&&(t=!1),!n.l&&n.h.D&&n.m&&d(r,t);}function z(n,r){var t=n[Q];return (t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t);}}function k(n){n.P||(n.P=!0,n.l&&k(n.l));}function E(n){n.o||(n.o=l(n.t));}function N(n,r,t){var e=s(r)?b("MapSet").F(r,t):v(r)?b("MapSet").T(r,t):n.O?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:null,o:null,j:null,C:!1},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b("ES5").J(r,t);return (t?t.A:_()).p.push(e),e}function R(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b("ES5").K(u)))return u.t;u.I=!0,e=D(r,c),u.I=!1;}else e=D(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t));})),3===c?new Set(e):e}(e)}function D(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}function F(){function t(n,r){var t=s[n];return t?t.enumerable=r:s[n]=t={configurable:!0,enumerable:r,get:function(){var r=this[Q];return "production"!==process.env.NODE_ENV&&f(r),en.get(r,n)},set:function(r){var t=this[Q];"production"!==process.env.NODE_ENV&&f(t),en.set(t,n,r);}},t}function e(n){for(var r=n.length-1;r>=0;r--){var t=n[r][Q];if(!t.P)switch(t.i){case 5:a(t)&&k(t);break;case 4:o(t)&&k(t);}}}function o(n){for(var r=n.t,t=n.k,e=nn(t),i=e.length-1;i>=0;i--){var o=e[i];if(o!==Q){var a=r[o];if(void 0===a&&!u(r,o))return !0;var f=t[o],s=f&&f[Q];if(s?s.t!==a:!c(f,a))return !0}}var v=!!r[Q];return e.length!==nn(r).length+(v?0:1)}function a(n){var r=n.k;if(r.length!==n.t.length)return !0;var t=Object.getOwnPropertyDescriptor(r,r.length-1);if(t&&!t.get)return !0;for(var e=0;e<r.length;e++)if(!r.hasOwnProperty(e))return !0;return !1}function f(r){r.g&&n(3,JSON.stringify(p(r)));}var s={};m("ES5",{J:function(n,r){var e=Array.isArray(n),i=function(n,r){if(n){for(var e=Array(r.length),i=0;i<r.length;i++)Object.defineProperty(e,""+i,t(i,!0));return e}var o=rn(r);delete o[Q];for(var u=nn(o),a=0;a<u.length;a++){var f=u[a];o[f]=t(f,n||!!o[f].enumerable);}return Object.create(Object.getPrototypeOf(r),o)}(e,n),o={i:e?5:4,A:r?r.A:_(),P:!1,I:!1,R:{},l:r,t:n,k:i,o:null,g:!1,C:!1};return Object.defineProperty(i,Q,{value:o,writable:!0}),i},S:function(n,t,o){o?r(t)&&t[Q].A===n&&e(n.p):(n.u&&function n(r){if(r&&"object"==typeof r){var t=r[Q];if(t){var e=t.t,o=t.k,f=t.R,c=t.i;if(4===c)i(o,(function(r){r!==Q&&(void 0!==e[r]||u(e,r)?f[r]||n(o[r]):(f[r]=!0,k(t)));})),i(e,(function(n){void 0!==o[n]||u(o,n)||(f[n]=!1,k(t));}));else if(5===c){if(a(t)&&(k(t),f.length=!0),o.length<e.length)for(var s=o.length;s<e.length;s++)f[s]=!1;else for(var v=e.length;v<o.length;v++)f[v]=!0;for(var p=Math.min(o.length,e.length),l=0;l<p;l++)o.hasOwnProperty(l)||(f[l]=!0),void 0===f[l]&&n(o[l]);}}}}(n.p[0]),e(n.p));},K:function(n){return 4===n.i?o(n):a(n)}});}var G,U,W="undefined"!=typeof Symbol&&"symbol"==typeof Symbol("x"),X="undefined"!=typeof Map,q="undefined"!=typeof Set,B="undefined"!=typeof Proxy&&void 0!==Proxy.revocable&&"undefined"!=typeof Reflect,H=W?Symbol.for("immer-nothing"):((G={})["immer-nothing"]=!0,G),L=W?Symbol.for("immer-draftable"):"__$immer_draftable",Q=W?Symbol.for("immer-state"):"__$immer_state",Y={0:"Illegal state",1:"Immer drafts cannot have computed properties",2:"This object has been frozen and should not be mutated",3:function(n){return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? "+n},4:"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",5:"Immer forbids circular references",6:"The first or second argument to `produce` must be a function",7:"The third argument to `produce` must be a function or undefined",8:"First argument to `createDraft` must be a plain object, an array, or an immerable object",9:"First argument to `finishDraft` must be a draft returned by `createDraft`",10:"The given draft is already finalized",11:"Object.defineProperty() cannot be used on an Immer draft",12:"Object.setPrototypeOf() cannot be used on an Immer draft",13:"Immer only supports deleting array indices",14:"Immer only supports setting array indices and the 'length' property",15:function(n){return "Cannot apply patch, path doesn't resolve: "+n},16:'Sets cannot have "replace" patches.',17:function(n){return "Unsupported patch operation: "+n},18:function(n){return "The plugin for '"+n+"' has not been loaded into Immer. To enable the plugin, import and call `enable"+n+"()` when initializing your application."},20:"Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available",21:function(n){return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '"+n+"'"},22:function(n){return "'current' expects a draft, got: "+n},23:function(n){return "'original' expects a draft, got: "+n},24:"Patching reserved attributes like __proto__, prototype and constructor is not allowed"},Z=""+Object.prototype.constructor,nn="undefined"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(n){return Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n))}:Object.getOwnPropertyNames,rn=Object.getOwnPropertyDescriptors||function(n){var r={};return nn(n).forEach((function(t){r[t]=Object.getOwnPropertyDescriptor(n,t);})),r},tn={},en={get:function(n,r){if(r===Q)return n;var e=p(n);if(!u(e,r))return function(n,r,t){var e,i=I(r,t);return i?"value"in i?i.value:null===(e=i.get)||void 0===e?void 0:e.call(n.k):void 0}(n,e,r);var i=e[r];return n.I||!t(i)?i:i===z(n.t,r)?(E(n),n.o[r]=N(n.A.h,i,n)):i},has:function(n,r){return r in p(n)},ownKeys:function(n){return Reflect.ownKeys(p(n))},set:function(n,r,t){var e=I(p(n),r);if(null==e?void 0:e.set)return e.set.call(n.k,t),!0;if(!n.P){var i=z(p(n),r),o=null==i?void 0:i[Q];if(o&&o.t===t)return n.o[r]=t,n.R[r]=!1,!0;if(c(t,i)&&(void 0!==t||u(n.t,r)))return !0;E(n),k(n);}return n.o[r]===t&&(void 0!==t||r in n.o)||Number.isNaN(t)&&Number.isNaN(n.o[r])||(n.o[r]=t,n.R[r]=!0),!0},deleteProperty:function(n,r){return void 0!==z(n.t,r)||r in n.t?(n.R[r]=!1,E(n),k(n)):delete n.R[r],n.o&&delete n.o[r],!0},getOwnPropertyDescriptor:function(n,r){var t=p(n),e=Reflect.getOwnPropertyDescriptor(t,r);return e?{writable:!0,configurable:1!==n.i||"length"!==r,enumerable:e.enumerable,value:t[r]}:e},defineProperty:function(){n(11);},getPrototypeOf:function(n){return Object.getPrototypeOf(n.t)},setPrototypeOf:function(){n(12);}},on={};i(en,(function(n,r){on[n]=function(){return arguments[0]=arguments[0][0],r.apply(this,arguments)};})),on.deleteProperty=function(r,t){return "production"!==process.env.NODE_ENV&&isNaN(parseInt(t))&&n(13),on.set.call(this,r,t,void 0)},on.set=function(r,t,e){return "production"!==process.env.NODE_ENV&&"length"!==t&&isNaN(parseInt(t))&&n(14),en.set.call(this,r[0],t,e,r[0])};var un=function(){function e(r){var e=this;this.O=B,this.D=!0,this.produce=function(r,i,o){if("function"==typeof r&&"function"!=typeof i){var u=i;i=r;var a=e;return function(n){var r=this;void 0===n&&(n=u);for(var t=arguments.length,e=Array(t>1?t-1:0),o=1;o<t;o++)e[o-1]=arguments[o];return a.produce(n,(function(n){var t;return (t=i).call.apply(t,[r,n].concat(e))}))}}var f;if("function"!=typeof i&&n(6),void 0!==o&&"function"!=typeof o&&n(7),t(r)){var c=w(e),s=N(e,r,void 0),v=!0;try{f=i(s),v=!1;}finally{v?g(c):O(c);}return "undefined"!=typeof Promise&&f instanceof Promise?f.then((function(n){return j(c,o),P(n,c)}),(function(n){throw g(c),n})):(j(c,o),P(f,c))}if(!r||"object"!=typeof r){if(void 0===(f=i(r))&&(f=r),f===H&&(f=void 0),e.D&&d(f,!0),o){var p=[],l=[];b("Patches").M(r,f,p,l),o(p,l);}return f}n(21,r);},this.produceWithPatches=function(n,r){if("function"==typeof n)return function(r){for(var t=arguments.length,i=Array(t>1?t-1:0),o=1;o<t;o++)i[o-1]=arguments[o];return e.produceWithPatches(r,(function(r){return n.apply(void 0,[r].concat(i))}))};var t,i,o=e.produce(n,r,(function(n,r){t=n,i=r;}));return "undefined"!=typeof Promise&&o instanceof Promise?o.then((function(n){return [n,t,i]})):[o,t,i]},"boolean"==typeof(null==r?void 0:r.useProxies)&&this.setUseProxies(r.useProxies),"boolean"==typeof(null==r?void 0:r.autoFreeze)&&this.setAutoFreeze(r.autoFreeze);}var i=e.prototype;return i.createDraft=function(e){t(e)||n(8),r(e)&&(e=R(e));var i=w(this),o=N(this,e,void 0);return o[Q].C=!0,O(i),o},i.finishDraft=function(r,t){var e=r&&r[Q];"production"!==process.env.NODE_ENV&&(e&&e.C||n(9),e.I&&n(10));var i=e.A;return j(i,t),P(void 0,i)},i.setAutoFreeze=function(n){this.D=n;},i.setUseProxies=function(r){r&&!B&&n(20),this.O=r;},i.applyPatches=function(n,t){var e;for(e=t.length-1;e>=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b("Patches").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce;an.produceWithPatches.bind(an);an.setAutoFreeze.bind(an);an.setUseProxies.bind(an);an.applyPatches.bind(an);an.createDraft.bind(an);an.finishDraft.bind(an);
@@ -185,35 +150,29 @@
     }, _typeof(o);
   }
 
-  function _toPrimitive(input, hint) {
-    if (_typeof(input) !== "object" || input === null) return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== undefined) {
-      var res = prim.call(input, hint || "default");
-      if (_typeof(res) !== "object") return res;
+  function toPrimitive(t, r) {
+    if ("object" != _typeof(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof(i)) return i;
       throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    return (hint === "string" ? String : Number)(input);
+    return ("string" === r ? String : Number)(t);
   }
 
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return _typeof(key) === "symbol" ? key : String(key);
+  function toPropertyKey(t) {
+    var i = toPrimitive(t, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
   }
 
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
+  function _defineProperty(e, r, t) {
+    return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
   }
 
   function ownKeys(e, r) {
@@ -600,7 +559,6 @@
       throw new Error(message);
     } catch (e) {} // eslint-disable-line no-empty
   }
-
   function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
     var reducerKeys = Object.keys(reducers);
     var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';
@@ -2146,7 +2104,7 @@
         };
       });
       var displayedWarning = false;
-      var AC = typeof AbortController !== "undefined" ? AbortController : ( /** @class */function () {
+      var AC = typeof AbortController !== "undefined" ? AbortController : (/** @class */function () {
         function class_1() {
           this.signal = {
             aborted: false,
@@ -4347,14 +4305,14 @@
     root = _root;
 
   /* Built-in method references that are verified to be native. */
-  var WeakMap$1 = getNative(root, 'WeakMap');
-  var _WeakMap = WeakMap$1;
+  var WeakMap$2 = getNative(root, 'WeakMap');
+  var _WeakMap = WeakMap$2;
 
   var DataView = _DataView,
     Map$1 = _Map,
     Promise$1 = _Promise,
     Set$1 = _Set,
-    WeakMap = _WeakMap,
+    WeakMap$1 = _WeakMap,
     baseGetTag$1 = _baseGetTag,
     toSource = _toSource;
 
@@ -4371,7 +4329,7 @@
     mapCtorString = toSource(Map$1),
     promiseCtorString = toSource(Promise$1),
     setCtorString = toSource(Set$1),
-    weakMapCtorString = toSource(WeakMap);
+    weakMapCtorString = toSource(WeakMap$1);
 
   /**
    * Gets the `toStringTag` of `value`.
@@ -4383,7 +4341,7 @@
   var getTag$1 = baseGetTag$1;
 
   // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
-  if (DataView && getTag$1(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag$1(new Map$1()) != mapTag || Promise$1 && getTag$1(Promise$1.resolve()) != promiseTag || Set$1 && getTag$1(new Set$1()) != setTag || WeakMap && getTag$1(new WeakMap()) != weakMapTag) {
+  if (DataView && getTag$1(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag$1(new Map$1()) != mapTag || Promise$1 && getTag$1(Promise$1.resolve()) != promiseTag || Set$1 && getTag$1(new Set$1()) != setTag || WeakMap$1 && getTag$1(new WeakMap$1()) != weakMapTag) {
     getTag$1 = function (value) {
       var result = baseGetTag$1(value),
         Ctor = result == objectTag$1 ? value.constructor : undefined,
@@ -5681,181 +5639,2953 @@
       const currentNextFn = next;
       next = compose(middleware(store))(currentNextFn); // wrap the previous `next` function with this new one, a la redux
     };
-
     return action => next(action);
   };
 
-  var useAction = function useAction(action, deps) {
-    return useActions([action], deps)[0];
-  };
-  var useActions = function useActions(actions, deps) {
-    var dispatch = reactRedux.useDispatch();
-    return react.useMemo(function () {
-      if (Array.isArray(actions)) {
-        return actions.map(function (a) {
-          return bindActionCreators(a, dispatch);
-        });
+  var react = {exports: {}};
+
+  var react_production_min = {};
+
+  /**
+   * @license React
+   * react.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredReact_production_min;
+  function requireReact_production_min() {
+    if (hasRequiredReact_production_min) return react_production_min;
+    hasRequiredReact_production_min = 1;
+    var l = Symbol.for("react.element"),
+      n = Symbol.for("react.portal"),
+      p = Symbol.for("react.fragment"),
+      q = Symbol.for("react.strict_mode"),
+      r = Symbol.for("react.profiler"),
+      t = Symbol.for("react.provider"),
+      u = Symbol.for("react.context"),
+      v = Symbol.for("react.forward_ref"),
+      w = Symbol.for("react.suspense"),
+      x = Symbol.for("react.memo"),
+      y = Symbol.for("react.lazy"),
+      z = Symbol.iterator;
+    function A(a) {
+      if (null === a || "object" !== typeof a) return null;
+      a = z && a[z] || a["@@iterator"];
+      return "function" === typeof a ? a : null;
+    }
+    var B = {
+        isMounted: function () {
+          return !1;
+        },
+        enqueueForceUpdate: function () {},
+        enqueueReplaceState: function () {},
+        enqueueSetState: function () {}
+      },
+      C = Object.assign,
+      D = {};
+    function E(a, b, e) {
+      this.props = a;
+      this.context = b;
+      this.refs = D;
+      this.updater = e || B;
+    }
+    E.prototype.isReactComponent = {};
+    E.prototype.setState = function (a, b) {
+      if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+      this.updater.enqueueSetState(this, a, b, "setState");
+    };
+    E.prototype.forceUpdate = function (a) {
+      this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+    };
+    function F() {}
+    F.prototype = E.prototype;
+    function G(a, b, e) {
+      this.props = a;
+      this.context = b;
+      this.refs = D;
+      this.updater = e || B;
+    }
+    var H = G.prototype = new F();
+    H.constructor = G;
+    C(H, E.prototype);
+    H.isPureReactComponent = !0;
+    var I = Array.isArray,
+      J = Object.prototype.hasOwnProperty,
+      K = {
+        current: null
+      },
+      L = {
+        key: !0,
+        ref: !0,
+        __self: !0,
+        __source: !0
+      };
+    function M(a, b, e) {
+      var d,
+        c = {},
+        k = null,
+        h = null;
+      if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+      var g = arguments.length - 2;
+      if (1 === g) c.children = e;else if (1 < g) {
+        for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+        c.children = f;
       }
-      return bindActionCreators(actions, dispatch);
-    }, /* eslint-disable-next-line react-hooks/exhaustive-deps */
-    deps ? [dispatch].concat(_toConsumableArray(deps)) : [dispatch]);
-  };
-
-  var asyncReducers = {}; // placeholder for injected reducers
-
-  var injectReducer = function injectReducer(store) {
-    var staticReducers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var key = arguments.length > 2 ? arguments[2] : undefined;
-    var asyncReducer = arguments.length > 3 ? arguments[3] : undefined;
-    if (!asyncReducers[key]) {
-      asyncReducers[key] = asyncReducer;
-      store.replaceReducer(combineReducers(_objectSpread2$1(_objectSpread2$1({}, staticReducers), asyncReducers)));
+      if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+      return {
+        $$typeof: l,
+        type: a,
+        key: k,
+        ref: h,
+        props: c,
+        _owner: K.current
+      };
     }
-  };
-  var injectSlice = function injectSlice(store, staticReducers, slice) {
-    return injectReducer(store, staticReducers, slice.name, slice.reducer);
-  };
-  var getSetterActionName = function getSetterActionName(name) {
-    return "set".concat(upperFirst_1(name));
-  };
-  var makeSetterReducersFromInitialState = function makeSetterReducersFromInitialState(initialState, config, pluginsData) {
-    var reducer = {};
-    Object.keys(initialState).forEach(function (name) {
-      var key = getSetterActionName(name);
-      reducer[key] = function (state, action) {
-        var value = action.payload;
-        pluginsData[name].forEach(function (_ref) {
-          var data = _ref.data,
-            plugin = _ref.plugin;
-          value = plugin.update(value, _objectSpread2$1({
-            state: state,
-            config: plugin.config,
-            draft: state
-          }, data)); // provide both state. and draft. apis so fewer users complain
+    function N(a, b) {
+      return {
+        $$typeof: l,
+        type: a.type,
+        key: b,
+        ref: a.ref,
+        props: a.props,
+        _owner: a._owner
+      };
+    }
+    function O(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === l;
+    }
+    function escape(a) {
+      var b = {
+        "=": "=0",
+        ":": "=2"
+      };
+      return "$" + a.replace(/[=:]/g, function (a) {
+        return b[a];
+      });
+    }
+    var P = /\/+/g;
+    function Q(a, b) {
+      return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+    }
+    function R(a, b, e, d, c) {
+      var k = typeof a;
+      if ("undefined" === k || "boolean" === k) a = null;
+      var h = !1;
+      if (null === a) h = !0;else switch (k) {
+        case "string":
+        case "number":
+          h = !0;
+          break;
+        case "object":
+          switch (a.$$typeof) {
+            case l:
+            case n:
+              h = !0;
+          }
+      }
+      if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function (a) {
+        return a;
+      })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+      h = 0;
+      d = "" === d ? "." : d + ":";
+      if (I(a)) for (var g = 0; g < a.length; g++) {
+        k = a[g];
+        var f = d + Q(k, g);
+        h += R(k, b, e, f, c);
+      } else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done;) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+      return h;
+    }
+    function S(a, b, e) {
+      if (null == a) return a;
+      var d = [],
+        c = 0;
+      R(a, d, "", "", function (a) {
+        return b.call(e, a, c++);
+      });
+      return d;
+    }
+    function T(a) {
+      if (-1 === a._status) {
+        var b = a._result;
+        b = b();
+        b.then(function (b) {
+          if (0 === a._status || -1 === a._status) a._status = 1, a._result = b;
+        }, function (b) {
+          if (0 === a._status || -1 === a._status) a._status = 2, a._result = b;
         });
-
-        state[name] = value;
+        -1 === a._status && (a._status = 0, a._result = b);
+      }
+      if (1 === a._status) return a._result.default;
+      throw a._result;
+    }
+    var U = {
+        current: null
+      },
+      V = {
+        transition: null
+      },
+      W = {
+        ReactCurrentDispatcher: U,
+        ReactCurrentBatchConfig: V,
+        ReactCurrentOwner: K
       };
-    });
-    return reducer;
-  };
-
-  /* eslint-enable react/forbid-foreign-prop-types */
-
-  var plugin = function plugin(_ref) {
-    var constructorFn = _ref.constructor,
-      setup = _ref.setup,
-      getInitialValue = _ref.getInitialValue,
-      update = _ref.update,
-      _ref$config = _ref.config,
-      config = _ref$config === void 0 ? {} : _ref$config;
-    return /*#__PURE__*/function () {
-      function _class(value) {
-        _classCallCheck(this, _class);
-        this.value = value;
-        this.setup = setup || this.setup;
-        this.getInitialValue = getInitialValue || this.getInitialValue;
-        this.update = update || this.update;
-        this.config = config;
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-        constructorFn === null || constructorFn === void 0 || constructorFn.call.apply(constructorFn, [this, value].concat(args));
+    function X() {
+      throw Error("act(...) is not supported in production builds of React.");
+    }
+    react_production_min.Children = {
+      map: S,
+      forEach: function (a, b, e) {
+        S(a, function () {
+          b.apply(this, arguments);
+        }, e);
+      },
+      count: function (a) {
+        var b = 0;
+        S(a, function () {
+          b++;
+        });
+        return b;
+      },
+      toArray: function (a) {
+        return S(a, function (a) {
+          return a;
+        }) || [];
+      },
+      only: function (a) {
+        if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+        return a;
       }
-
-      // either the initial state value or the next plugin
-      _createClass(_class, [{
-        key: "getValue",
-        value: function getValue() {
-          return this.value;
-        }
-      }, {
-        key: "setValue",
-        value: function setValue(value) {
-          this.value = value;
-        }
-      }, {
-        key: "setConfig",
-        value: function setConfig(config) {
-          this.config = _objectSpread2$1(_objectSpread2$1({}, this.config), config);
-        }
-      }, {
-        key: "setup",
-        value: function setup(item, _ref2) {
-          _objectDestructuringEmpty(_ref2);
-          return {
-            plugin: item
-          };
-        }
-      }, {
-        key: "getInitialValue",
-        value: function getInitialValue(value, _ref3) {
-          _objectDestructuringEmpty(_ref3);
-          return value;
-        }
-      }, {
-        key: "update",
-        value: function update(value, _ref4) {
-          _objectDestructuringEmpty(_ref4);
-          return value;
-        }
-      }]);
-      return _class;
-    }();
-  };
-  var addPlugin = function addPlugin(config) {
-    var Class = plugin(config);
-    plugins.push(Class);
-    return function () {
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
+    };
+    react_production_min.Component = E;
+    react_production_min.Fragment = p;
+    react_production_min.Profiler = r;
+    react_production_min.PureComponent = G;
+    react_production_min.StrictMode = q;
+    react_production_min.Suspense = w;
+    react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+    react_production_min.act = X;
+    react_production_min.cloneElement = function (a, b, e) {
+      if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+      var d = C({}, a.props),
+        c = a.key,
+        k = a.ref,
+        h = a._owner;
+      if (null != b) {
+        void 0 !== b.ref && (k = b.ref, h = K.current);
+        void 0 !== b.key && (c = "" + b.key);
+        if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+        for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
       }
-      return _construct(Class, args);
+      var f = arguments.length - 2;
+      if (1 === f) d.children = e;else if (1 < f) {
+        g = Array(f);
+        for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+        d.children = g;
+      }
+      return {
+        $$typeof: l,
+        type: a.type,
+        key: c,
+        ref: k,
+        props: d,
+        _owner: h
+      };
     };
-  };
-  var addPlugins = function addPlugins() {
-    for (var _len3 = arguments.length, configs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      configs[_key3] = arguments[_key3];
-    }
-    return configs.map(addPlugin);
-  };
-  var plugins = [];
-
-  var makeSelectorHook = function makeSelectorHook(selector) {
-    return function () {
-      return reactRedux.useSelector(selector, reactRedux.shallowEqual);
+    react_production_min.createContext = function (a) {
+      a = {
+        $$typeof: u,
+        _currentValue: a,
+        _currentValue2: a,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null,
+        _defaultValue: null,
+        _globalName: null
+      };
+      a.Provider = {
+        $$typeof: t,
+        _context: a
+      };
+      return a.Consumer = a;
     };
-  };
-  var createSelectorUpdateHook = function createSelectorUpdateHook(selector, action) {
-    return function () {
-      return [reactRedux.useSelector(selector), useAction(action, undefined)];
+    react_production_min.createElement = M;
+    react_production_min.createFactory = function (a) {
+      var b = M.bind(null, a);
+      b.type = a;
+      return b;
     };
-  };
-  var createSelectorHook = function createSelectorHook() {
-    // creates a redux selector and a react hook that produce identical results
-    var selector = createDraftSafeSelector.apply(void 0, arguments);
-    var hook = makeSelectorHook(selector);
-    hook.select = selector;
-    return hook;
-  };
-  var configure$1 = function configure(store) {
-    var makeDomainSelector = function makeDomainSelector(name, initialState) {
-      return function (state) {
-        return (state === null || state === void 0 ? void 0 : state[name]) || initialState;
+    react_production_min.createRef = function () {
+      return {
+        current: null
       };
     };
-    var makeDomainSelectorFromSlice = function makeDomainSelectorFromSlice(slice) {
-      return makeDomainSelector(slice.name, slice.getInitialState());
+    react_production_min.forwardRef = function (a) {
+      return {
+        $$typeof: v,
+        render: a
+      };
     };
-    var selectProp = function selectProp(name, defaultValue) {
-      return function (substate) {
-        return get_1(substate, name, defaultValue);
+    react_production_min.isValidElement = O;
+    react_production_min.lazy = function (a) {
+      return {
+        $$typeof: y,
+        _payload: {
+          _status: -1,
+          _result: a
+        },
+        _init: T
       };
     };
-    var makePropertySelectorHookFactory = function makePropertySelectorHookFactory(baseSelector, slice) {
-      return function (names) {
-        // to be used in conjunction with singlePropReducer to mimic the useState api,
-        //  but for individual pieces of redux state rather than component state
+    react_production_min.memo = function (a, b) {
+      return {
+        $$typeof: x,
+        type: a,
+        compare: void 0 === b ? null : b
+      };
+    };
+    react_production_min.startTransition = function (a) {
+      var b = V.transition;
+      V.transition = {};
+      try {
+        a();
+      } finally {
+        V.transition = b;
+      }
+    };
+    react_production_min.unstable_act = X;
+    react_production_min.useCallback = function (a, b) {
+      return U.current.useCallback(a, b);
+    };
+    react_production_min.useContext = function (a) {
+      return U.current.useContext(a);
+    };
+    react_production_min.useDebugValue = function () {};
+    react_production_min.useDeferredValue = function (a) {
+      return U.current.useDeferredValue(a);
+    };
+    react_production_min.useEffect = function (a, b) {
+      return U.current.useEffect(a, b);
+    };
+    react_production_min.useId = function () {
+      return U.current.useId();
+    };
+    react_production_min.useImperativeHandle = function (a, b, e) {
+      return U.current.useImperativeHandle(a, b, e);
+    };
+    react_production_min.useInsertionEffect = function (a, b) {
+      return U.current.useInsertionEffect(a, b);
+    };
+    react_production_min.useLayoutEffect = function (a, b) {
+      return U.current.useLayoutEffect(a, b);
+    };
+    react_production_min.useMemo = function (a, b) {
+      return U.current.useMemo(a, b);
+    };
+    react_production_min.useReducer = function (a, b, e) {
+      return U.current.useReducer(a, b, e);
+    };
+    react_production_min.useRef = function (a) {
+      return U.current.useRef(a);
+    };
+    react_production_min.useState = function (a) {
+      return U.current.useState(a);
+    };
+    react_production_min.useSyncExternalStore = function (a, b, e) {
+      return U.current.useSyncExternalStore(a, b, e);
+    };
+    react_production_min.useTransition = function () {
+      return U.current.useTransition();
+    };
+    react_production_min.version = "18.3.1";
+    return react_production_min;
+  }
+
+  var react_development = {exports: {}};
+
+  /**
+   * @license React
+   * react.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredReact_development;
+  function requireReact_development() {
+    if (hasRequiredReact_development) return react_development.exports;
+    hasRequiredReact_development = 1;
+    (function (module, exports) {
+
+      if (process.env.NODE_ENV !== "production") {
+        (function () {
+
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+          if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === 'function') {
+            __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+          }
+          var ReactVersion = '18.3.1';
+
+          // ATTENTION
+          // When adding new symbols to this file,
+          // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+          // The Symbol used to tag the ReactElement-like types.
+          var REACT_ELEMENT_TYPE = Symbol.for('react.element');
+          var REACT_PORTAL_TYPE = Symbol.for('react.portal');
+          var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
+          var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
+          var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
+          var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
+          var REACT_CONTEXT_TYPE = Symbol.for('react.context');
+          var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
+          var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
+          var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
+          var REACT_MEMO_TYPE = Symbol.for('react.memo');
+          var REACT_LAZY_TYPE = Symbol.for('react.lazy');
+          var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
+          var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+          var FAUX_ITERATOR_SYMBOL = '@@iterator';
+          function getIteratorFn(maybeIterable) {
+            if (maybeIterable === null || typeof maybeIterable !== 'object') {
+              return null;
+            }
+            var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+            if (typeof maybeIterator === 'function') {
+              return maybeIterator;
+            }
+            return null;
+          }
+
+          /**
+           * Keeps track of the current dispatcher.
+           */
+          var ReactCurrentDispatcher = {
+            /**
+             * @internal
+             * @type {ReactComponent}
+             */
+            current: null
+          };
+
+          /**
+           * Keeps track of the current batch's configuration such as how long an update
+           * should suspend for if it needs to.
+           */
+          var ReactCurrentBatchConfig = {
+            transition: null
+          };
+          var ReactCurrentActQueue = {
+            current: null,
+            // Used to reproduce behavior of `batchedUpdates` in legacy mode.
+            isBatchingLegacy: false,
+            didScheduleLegacyUpdate: false
+          };
+
+          /**
+           * Keeps track of the current owner.
+           *
+           * The current owner is the component who should own any components that are
+           * currently being constructed.
+           */
+          var ReactCurrentOwner = {
+            /**
+             * @internal
+             * @type {ReactComponent}
+             */
+            current: null
+          };
+          var ReactDebugCurrentFrame = {};
+          var currentExtraStackFrame = null;
+          function setExtraStackFrame(stack) {
+            {
+              currentExtraStackFrame = stack;
+            }
+          }
+          {
+            ReactDebugCurrentFrame.setExtraStackFrame = function (stack) {
+              {
+                currentExtraStackFrame = stack;
+              }
+            }; // Stack implementation injected by the current renderer.
+
+            ReactDebugCurrentFrame.getCurrentStack = null;
+            ReactDebugCurrentFrame.getStackAddendum = function () {
+              var stack = ''; // Add an extra top frame while an element is being validated
+
+              if (currentExtraStackFrame) {
+                stack += currentExtraStackFrame;
+              } // Delegate to the injected renderer-specific implementation
+
+              var impl = ReactDebugCurrentFrame.getCurrentStack;
+              if (impl) {
+                stack += impl() || '';
+              }
+              return stack;
+            };
+          }
+
+          // -----------------------------------------------------------------------------
+
+          var enableScopeAPI = false; // Experimental Create Event Handle API.
+          var enableCacheElement = false;
+          var enableTransitionTracing = false; // No known bugs, but needs performance testing
+
+          var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
+          // stuff. Intended to enable React core members to more easily debug scheduling
+          // issues in DEV builds.
+
+          var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+
+          var ReactSharedInternals = {
+            ReactCurrentDispatcher: ReactCurrentDispatcher,
+            ReactCurrentBatchConfig: ReactCurrentBatchConfig,
+            ReactCurrentOwner: ReactCurrentOwner
+          };
+          {
+            ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
+            ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
+          }
+
+          // by calls to these methods by a Babel plugin.
+          //
+          // In PROD (or in packages without access to React internals),
+          // they are left as they are instead.
+
+          function warn(format) {
+            {
+              {
+                for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+                  args[_key - 1] = arguments[_key];
+                }
+                printWarning('warn', format, args);
+              }
+            }
+          }
+          function error(format) {
+            {
+              {
+                for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+                  args[_key2 - 1] = arguments[_key2];
+                }
+                printWarning('error', format, args);
+              }
+            }
+          }
+          function printWarning(level, format, args) {
+            // When changing this logic, you might want to also
+            // update consoleWithStackDev.www.js as well.
+            {
+              var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+              var stack = ReactDebugCurrentFrame.getStackAddendum();
+              if (stack !== '') {
+                format += '%s';
+                args = args.concat([stack]);
+              } // eslint-disable-next-line react-internal/safe-string-coercion
+
+              var argsWithFormat = args.map(function (item) {
+                return String(item);
+              }); // Careful: RN currently depends on this prefix
+
+              argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+              // breaks IE9: https://github.com/facebook/react/issues/13610
+              // eslint-disable-next-line react-internal/no-production-logging
+
+              Function.prototype.apply.call(console[level], console, argsWithFormat);
+            }
+          }
+          var didWarnStateUpdateForUnmountedComponent = {};
+          function warnNoop(publicInstance, callerName) {
+            {
+              var _constructor = publicInstance.constructor;
+              var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
+              var warningKey = componentName + "." + callerName;
+              if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
+                return;
+              }
+              error("Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);
+              didWarnStateUpdateForUnmountedComponent[warningKey] = true;
+            }
+          }
+          /**
+           * This is the abstract API for an update queue.
+           */
+
+          var ReactNoopUpdateQueue = {
+            /**
+             * Checks whether or not this composite component is mounted.
+             * @param {ReactClass} publicInstance The instance we want to test.
+             * @return {boolean} True if mounted, false otherwise.
+             * @protected
+             * @final
+             */
+            isMounted: function (publicInstance) {
+              return false;
+            },
+            /**
+             * Forces an update. This should only be invoked when it is known with
+             * certainty that we are **not** in a DOM transaction.
+             *
+             * You may want to call this when you know that some deeper aspect of the
+             * component's state has changed but `setState` was not called.
+             *
+             * This will not invoke `shouldComponentUpdate`, but it will invoke
+             * `componentWillUpdate` and `componentDidUpdate`.
+             *
+             * @param {ReactClass} publicInstance The instance that should rerender.
+             * @param {?function} callback Called after component is updated.
+             * @param {?string} callerName name of the calling function in the public API.
+             * @internal
+             */
+            enqueueForceUpdate: function (publicInstance, callback, callerName) {
+              warnNoop(publicInstance, 'forceUpdate');
+            },
+            /**
+             * Replaces all of the state. Always use this or `setState` to mutate state.
+             * You should treat `this.state` as immutable.
+             *
+             * There is no guarantee that `this.state` will be immediately updated, so
+             * accessing `this.state` after calling this method may return the old value.
+             *
+             * @param {ReactClass} publicInstance The instance that should rerender.
+             * @param {object} completeState Next state.
+             * @param {?function} callback Called after component is updated.
+             * @param {?string} callerName name of the calling function in the public API.
+             * @internal
+             */
+            enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
+              warnNoop(publicInstance, 'replaceState');
+            },
+            /**
+             * Sets a subset of the state. This only exists because _pendingState is
+             * internal. This provides a merging strategy that is not available to deep
+             * properties which is confusing. TODO: Expose pendingState or don't use it
+             * during the merge.
+             *
+             * @param {ReactClass} publicInstance The instance that should rerender.
+             * @param {object} partialState Next partial state to be merged with state.
+             * @param {?function} callback Called after component is updated.
+             * @param {?string} Name of the calling function in the public API.
+             * @internal
+             */
+            enqueueSetState: function (publicInstance, partialState, callback, callerName) {
+              warnNoop(publicInstance, 'setState');
+            }
+          };
+          var assign = Object.assign;
+          var emptyObject = {};
+          {
+            Object.freeze(emptyObject);
+          }
+          /**
+           * Base class helpers for the updating state of a component.
+           */
+
+          function Component(props, context, updater) {
+            this.props = props;
+            this.context = context; // If a component has string refs, we will assign a different object later.
+
+            this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+            // renderer.
+
+            this.updater = updater || ReactNoopUpdateQueue;
+          }
+          Component.prototype.isReactComponent = {};
+          /**
+           * Sets a subset of the state. Always use this to mutate
+           * state. You should treat `this.state` as immutable.
+           *
+           * There is no guarantee that `this.state` will be immediately updated, so
+           * accessing `this.state` after calling this method may return the old value.
+           *
+           * There is no guarantee that calls to `setState` will run synchronously,
+           * as they may eventually be batched together.  You can provide an optional
+           * callback that will be executed when the call to setState is actually
+           * completed.
+           *
+           * When a function is provided to setState, it will be called at some point in
+           * the future (not synchronously). It will be called with the up to date
+           * component arguments (state, props, context). These values can be different
+           * from this.* because your function may be called after receiveProps but before
+           * shouldComponentUpdate, and this new state, props, and context will not yet be
+           * assigned to this.
+           *
+           * @param {object|function} partialState Next partial state or function to
+           *        produce next partial state to be merged with current state.
+           * @param {?function} callback Called after state is updated.
+           * @final
+           * @protected
+           */
+
+          Component.prototype.setState = function (partialState, callback) {
+            if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
+              throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');
+            }
+            this.updater.enqueueSetState(this, partialState, callback, 'setState');
+          };
+          /**
+           * Forces an update. This should only be invoked when it is known with
+           * certainty that we are **not** in a DOM transaction.
+           *
+           * You may want to call this when you know that some deeper aspect of the
+           * component's state has changed but `setState` was not called.
+           *
+           * This will not invoke `shouldComponentUpdate`, but it will invoke
+           * `componentWillUpdate` and `componentDidUpdate`.
+           *
+           * @param {?function} callback Called after update is complete.
+           * @final
+           * @protected
+           */
+
+          Component.prototype.forceUpdate = function (callback) {
+            this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
+          };
+          /**
+           * Deprecated APIs. These APIs used to exist on classic React classes but since
+           * we would like to deprecate them, we're not going to move them over to this
+           * modern base class. Instead, we define a getter that warns if it's accessed.
+           */
+
+          {
+            var deprecatedAPIs = {
+              isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
+              replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
+            };
+            var defineDeprecationWarning = function (methodName, info) {
+              Object.defineProperty(Component.prototype, methodName, {
+                get: function () {
+                  warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);
+                  return undefined;
+                }
+              });
+            };
+            for (var fnName in deprecatedAPIs) {
+              if (deprecatedAPIs.hasOwnProperty(fnName)) {
+                defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+              }
+            }
+          }
+          function ComponentDummy() {}
+          ComponentDummy.prototype = Component.prototype;
+          /**
+           * Convenience component with default shallow equality check for sCU.
+           */
+
+          function PureComponent(props, context, updater) {
+            this.props = props;
+            this.context = context; // If a component has string refs, we will assign a different object later.
+
+            this.refs = emptyObject;
+            this.updater = updater || ReactNoopUpdateQueue;
+          }
+          var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+          pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+
+          assign(pureComponentPrototype, Component.prototype);
+          pureComponentPrototype.isPureReactComponent = true;
+
+          // an immutable object with a single mutable value
+          function createRef() {
+            var refObject = {
+              current: null
+            };
+            {
+              Object.seal(refObject);
+            }
+            return refObject;
+          }
+          var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+          function isArray(a) {
+            return isArrayImpl(a);
+          }
+
+          /*
+           * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
+           * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
+           *
+           * The functions in this module will throw an easier-to-understand,
+           * easier-to-debug exception with a clear errors message message explaining the
+           * problem. (Instead of a confusing exception thrown inside the implementation
+           * of the `value` object).
+           */
+          // $FlowFixMe only called in DEV, so void return is not possible.
+          function typeName(value) {
+            {
+              // toStringTag is needed for namespaced types like Temporal.Instant
+              var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
+              var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
+              return type;
+            }
+          } // $FlowFixMe only called in DEV, so void return is not possible.
+
+          function willCoercionThrow(value) {
+            {
+              try {
+                testStringCoercion(value);
+                return false;
+              } catch (e) {
+                return true;
+              }
+            }
+          }
+          function testStringCoercion(value) {
+            // If you ended up here by following an exception call stack, here's what's
+            // happened: you supplied an object or symbol value to React (as a prop, key,
+            // DOM attribute, CSS property, string ref, etc.) and when React tried to
+            // coerce it to a string using `'' + value`, an exception was thrown.
+            //
+            // The most common types that will cause this exception are `Symbol` instances
+            // and Temporal objects like `Temporal.Instant`. But any object that has a
+            // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
+            // exception. (Library authors do this to prevent users from using built-in
+            // numeric operators like `+` or comparison operators like `>=` because custom
+            // methods are needed to perform accurate arithmetic or comparison.)
+            //
+            // To fix the problem, coerce this object or symbol value to a string before
+            // passing it to React. The most reliable way is usually `String(value)`.
+            //
+            // To find which value is throwing, check the browser or debugger console.
+            // Before this exception was thrown, there should be `console.error` output
+            // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
+            // problem and how that type was used: key, atrribute, input value prop, etc.
+            // In most cases, this console output also shows the component and its
+            // ancestor components where the exception happened.
+            //
+            // eslint-disable-next-line react-internal/safe-string-coercion
+            return '' + value;
+          }
+          function checkKeyStringCoercion(value) {
+            {
+              if (willCoercionThrow(value)) {
+                error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
+                return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
+              }
+            }
+          }
+          function getWrappedName(outerType, innerType, wrapperName) {
+            var displayName = outerType.displayName;
+            if (displayName) {
+              return displayName;
+            }
+            var functionName = innerType.displayName || innerType.name || '';
+            return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
+          } // Keep in sync with react-reconciler/getComponentNameFromFiber
+
+          function getContextName(type) {
+            return type.displayName || 'Context';
+          } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+          function getComponentNameFromType(type) {
+            if (type == null) {
+              // Host root, text node or just invalid type.
+              return null;
+            }
+            {
+              if (typeof type.tag === 'number') {
+                error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+              }
+            }
+            if (typeof type === 'function') {
+              return type.displayName || type.name || null;
+            }
+            if (typeof type === 'string') {
+              return type;
+            }
+            switch (type) {
+              case REACT_FRAGMENT_TYPE:
+                return 'Fragment';
+              case REACT_PORTAL_TYPE:
+                return 'Portal';
+              case REACT_PROFILER_TYPE:
+                return 'Profiler';
+              case REACT_STRICT_MODE_TYPE:
+                return 'StrictMode';
+              case REACT_SUSPENSE_TYPE:
+                return 'Suspense';
+              case REACT_SUSPENSE_LIST_TYPE:
+                return 'SuspenseList';
+            }
+            if (typeof type === 'object') {
+              switch (type.$$typeof) {
+                case REACT_CONTEXT_TYPE:
+                  var context = type;
+                  return getContextName(context) + '.Consumer';
+                case REACT_PROVIDER_TYPE:
+                  var provider = type;
+                  return getContextName(provider._context) + '.Provider';
+                case REACT_FORWARD_REF_TYPE:
+                  return getWrappedName(type, type.render, 'ForwardRef');
+                case REACT_MEMO_TYPE:
+                  var outerName = type.displayName || null;
+                  if (outerName !== null) {
+                    return outerName;
+                  }
+                  return getComponentNameFromType(type.type) || 'Memo';
+                case REACT_LAZY_TYPE:
+                  {
+                    var lazyComponent = type;
+                    var payload = lazyComponent._payload;
+                    var init = lazyComponent._init;
+                    try {
+                      return getComponentNameFromType(init(payload));
+                    } catch (x) {
+                      return null;
+                    }
+                  }
+
+                // eslint-disable-next-line no-fallthrough
+              }
+            }
+            return null;
+          }
+          var hasOwnProperty = Object.prototype.hasOwnProperty;
+          var RESERVED_PROPS = {
+            key: true,
+            ref: true,
+            __self: true,
+            __source: true
+          };
+          var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
+          {
+            didWarnAboutStringRefs = {};
+          }
+          function hasValidRef(config) {
+            {
+              if (hasOwnProperty.call(config, 'ref')) {
+                var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+                if (getter && getter.isReactWarning) {
+                  return false;
+                }
+              }
+            }
+            return config.ref !== undefined;
+          }
+          function hasValidKey(config) {
+            {
+              if (hasOwnProperty.call(config, 'key')) {
+                var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+                if (getter && getter.isReactWarning) {
+                  return false;
+                }
+              }
+            }
+            return config.key !== undefined;
+          }
+          function defineKeyPropWarningGetter(props, displayName) {
+            var warnAboutAccessingKey = function () {
+              {
+                if (!specialPropKeyWarningShown) {
+                  specialPropKeyWarningShown = true;
+                  error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+                }
+              }
+            };
+            warnAboutAccessingKey.isReactWarning = true;
+            Object.defineProperty(props, 'key', {
+              get: warnAboutAccessingKey,
+              configurable: true
+            });
+          }
+          function defineRefPropWarningGetter(props, displayName) {
+            var warnAboutAccessingRef = function () {
+              {
+                if (!specialPropRefWarningShown) {
+                  specialPropRefWarningShown = true;
+                  error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+                }
+              }
+            };
+            warnAboutAccessingRef.isReactWarning = true;
+            Object.defineProperty(props, 'ref', {
+              get: warnAboutAccessingRef,
+              configurable: true
+            });
+          }
+          function warnIfStringRefCannotBeAutoConverted(config) {
+            {
+              if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
+                var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+                if (!didWarnAboutStringRefs[componentName]) {
+                  error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref);
+                  didWarnAboutStringRefs[componentName] = true;
+                }
+              }
+            }
+          }
+          /**
+           * Factory method to create a new React element. This no longer adheres to
+           * the class pattern, so do not use new to call it. Also, instanceof check
+           * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+           * if something is a React Element.
+           *
+           * @param {*} type
+           * @param {*} props
+           * @param {*} key
+           * @param {string|object} ref
+           * @param {*} owner
+           * @param {*} self A *temporary* helper to detect places where `this` is
+           * different from the `owner` when React.createElement is called, so that we
+           * can warn. We want to get rid of owner and replace string `ref`s with arrow
+           * functions, and as long as `this` and owner are the same, there will be no
+           * change in behavior.
+           * @param {*} source An annotation object (added by a transpiler or otherwise)
+           * indicating filename, line number, and/or other information.
+           * @internal
+           */
+
+          var ReactElement = function (type, key, ref, self, source, owner, props) {
+            var element = {
+              // This tag allows us to uniquely identify this as a React Element
+              $$typeof: REACT_ELEMENT_TYPE,
+              // Built-in properties that belong on the element
+              type: type,
+              key: key,
+              ref: ref,
+              props: props,
+              // Record the component responsible for creating this element.
+              _owner: owner
+            };
+            {
+              // The validation flag is currently mutative. We put it on
+              // an external backing store so that we can freeze the whole object.
+              // This can be replaced with a WeakMap once they are implemented in
+              // commonly used development environments.
+              element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
+              // the validation flag non-enumerable (where possible, which should
+              // include every environment we run tests in), so the test framework
+              // ignores it.
+
+              Object.defineProperty(element._store, 'validated', {
+                configurable: false,
+                enumerable: false,
+                writable: true,
+                value: false
+              }); // self and source are DEV only properties.
+
+              Object.defineProperty(element, '_self', {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: self
+              }); // Two elements created in two different places should be considered
+              // equal for testing purposes and therefore we hide it from enumeration.
+
+              Object.defineProperty(element, '_source', {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: source
+              });
+              if (Object.freeze) {
+                Object.freeze(element.props);
+                Object.freeze(element);
+              }
+            }
+            return element;
+          };
+          /**
+           * Create and return a new ReactElement of the given type.
+           * See https://reactjs.org/docs/react-api.html#createelement
+           */
+
+          function createElement(type, config, children) {
+            var propName; // Reserved names are extracted
+
+            var props = {};
+            var key = null;
+            var ref = null;
+            var self = null;
+            var source = null;
+            if (config != null) {
+              if (hasValidRef(config)) {
+                ref = config.ref;
+                {
+                  warnIfStringRefCannotBeAutoConverted(config);
+                }
+              }
+              if (hasValidKey(config)) {
+                {
+                  checkKeyStringCoercion(config.key);
+                }
+                key = '' + config.key;
+              }
+              self = config.__self === undefined ? null : config.__self;
+              source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+              for (propName in config) {
+                if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                  props[propName] = config[propName];
+                }
+              }
+            } // Children can be more than one argument, and those are transferred onto
+            // the newly allocated props object.
+
+            var childrenLength = arguments.length - 2;
+            if (childrenLength === 1) {
+              props.children = children;
+            } else if (childrenLength > 1) {
+              var childArray = Array(childrenLength);
+              for (var i = 0; i < childrenLength; i++) {
+                childArray[i] = arguments[i + 2];
+              }
+              {
+                if (Object.freeze) {
+                  Object.freeze(childArray);
+                }
+              }
+              props.children = childArray;
+            } // Resolve default props
+
+            if (type && type.defaultProps) {
+              var defaultProps = type.defaultProps;
+              for (propName in defaultProps) {
+                if (props[propName] === undefined) {
+                  props[propName] = defaultProps[propName];
+                }
+              }
+            }
+            {
+              if (key || ref) {
+                var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+                if (key) {
+                  defineKeyPropWarningGetter(props, displayName);
+                }
+                if (ref) {
+                  defineRefPropWarningGetter(props, displayName);
+                }
+              }
+            }
+            return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+          }
+          function cloneAndReplaceKey(oldElement, newKey) {
+            var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+            return newElement;
+          }
+          /**
+           * Clone and return a new ReactElement using element as the starting point.
+           * See https://reactjs.org/docs/react-api.html#cloneelement
+           */
+
+          function cloneElement(element, config, children) {
+            if (element === null || element === undefined) {
+              throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+            }
+            var propName; // Original props are copied
+
+            var props = assign({}, element.props); // Reserved names are extracted
+
+            var key = element.key;
+            var ref = element.ref; // Self is preserved since the owner is preserved.
+
+            var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+            // transpiler, and the original source is probably a better indicator of the
+            // true owner.
+
+            var source = element._source; // Owner will be preserved, unless ref is overridden
+
+            var owner = element._owner;
+            if (config != null) {
+              if (hasValidRef(config)) {
+                // Silently steal the ref from the parent.
+                ref = config.ref;
+                owner = ReactCurrentOwner.current;
+              }
+              if (hasValidKey(config)) {
+                {
+                  checkKeyStringCoercion(config.key);
+                }
+                key = '' + config.key;
+              } // Remaining properties override existing props
+
+              var defaultProps;
+              if (element.type && element.type.defaultProps) {
+                defaultProps = element.type.defaultProps;
+              }
+              for (propName in config) {
+                if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+                  if (config[propName] === undefined && defaultProps !== undefined) {
+                    // Resolve default props
+                    props[propName] = defaultProps[propName];
+                  } else {
+                    props[propName] = config[propName];
+                  }
+                }
+              }
+            } // Children can be more than one argument, and those are transferred onto
+            // the newly allocated props object.
+
+            var childrenLength = arguments.length - 2;
+            if (childrenLength === 1) {
+              props.children = children;
+            } else if (childrenLength > 1) {
+              var childArray = Array(childrenLength);
+              for (var i = 0; i < childrenLength; i++) {
+                childArray[i] = arguments[i + 2];
+              }
+              props.children = childArray;
+            }
+            return ReactElement(element.type, key, ref, self, source, owner, props);
+          }
+          /**
+           * Verifies the object is a ReactElement.
+           * See https://reactjs.org/docs/react-api.html#isvalidelement
+           * @param {?object} object
+           * @return {boolean} True if `object` is a ReactElement.
+           * @final
+           */
+
+          function isValidElement(object) {
+            return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+          }
+          var SEPARATOR = '.';
+          var SUBSEPARATOR = ':';
+          /**
+           * Escape and wrap key so it is safe to use as a reactid
+           *
+           * @param {string} key to be escaped.
+           * @return {string} the escaped key.
+           */
+
+          function escape(key) {
+            var escapeRegex = /[=:]/g;
+            var escaperLookup = {
+              '=': '=0',
+              ':': '=2'
+            };
+            var escapedString = key.replace(escapeRegex, function (match) {
+              return escaperLookup[match];
+            });
+            return '$' + escapedString;
+          }
+          /**
+           * TODO: Test that a single child and an array with one item have the same key
+           * pattern.
+           */
+
+          var didWarnAboutMaps = false;
+          var userProvidedKeyEscapeRegex = /\/+/g;
+          function escapeUserProvidedKey(text) {
+            return text.replace(userProvidedKeyEscapeRegex, '$&/');
+          }
+          /**
+           * Generate a key string that identifies a element within a set.
+           *
+           * @param {*} element A element that could contain a manual key.
+           * @param {number} index Index that is used if a manual key is not provided.
+           * @return {string}
+           */
+
+          function getElementKey(element, index) {
+            // Do some typechecking here since we call this blindly. We want to ensure
+            // that we don't block potential future ES APIs.
+            if (typeof element === 'object' && element !== null && element.key != null) {
+              // Explicit key
+              {
+                checkKeyStringCoercion(element.key);
+              }
+              return escape('' + element.key);
+            } // Implicit key determined by the index in the set
+
+            return index.toString(36);
+          }
+          function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+            var type = typeof children;
+            if (type === 'undefined' || type === 'boolean') {
+              // All of the above are perceived as null.
+              children = null;
+            }
+            var invokeCallback = false;
+            if (children === null) {
+              invokeCallback = true;
+            } else {
+              switch (type) {
+                case 'string':
+                case 'number':
+                  invokeCallback = true;
+                  break;
+                case 'object':
+                  switch (children.$$typeof) {
+                    case REACT_ELEMENT_TYPE:
+                    case REACT_PORTAL_TYPE:
+                      invokeCallback = true;
+                  }
+              }
+            }
+            if (invokeCallback) {
+              var _child = children;
+              var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array
+              // so that it's consistent if the number of children grows:
+
+              var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
+              if (isArray(mappedChild)) {
+                var escapedChildKey = '';
+                if (childKey != null) {
+                  escapedChildKey = escapeUserProvidedKey(childKey) + '/';
+                }
+                mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) {
+                  return c;
+                });
+              } else if (mappedChild != null) {
+                if (isValidElement(mappedChild)) {
+                  {
+                    // The `if` statement here prevents auto-disabling of the safe
+                    // coercion ESLint rule, so we must manually disable it below.
+                    // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
+                    if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) {
+                      checkKeyStringCoercion(mappedChild.key);
+                    }
+                  }
+                  mappedChild = cloneAndReplaceKey(mappedChild,
+                  // Keep both the (mapped) and old keys if they differ, just as
+                  // traverseAllChildren used to do for objects as children
+                  escapedPrefix + (
+                  // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
+                  mappedChild.key && (!_child || _child.key !== mappedChild.key) ?
+                  // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
+                  // eslint-disable-next-line react-internal/safe-string-coercion
+                  escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey);
+                }
+                array.push(mappedChild);
+              }
+              return 1;
+            }
+            var child;
+            var nextName;
+            var subtreeCount = 0; // Count of children found in the current subtree.
+
+            var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+            if (isArray(children)) {
+              for (var i = 0; i < children.length; i++) {
+                child = children[i];
+                nextName = nextNamePrefix + getElementKey(child, i);
+                subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+              }
+            } else {
+              var iteratorFn = getIteratorFn(children);
+              if (typeof iteratorFn === 'function') {
+                var iterableChildren = children;
+                {
+                  // Warn about using Maps as children
+                  if (iteratorFn === iterableChildren.entries) {
+                    if (!didWarnAboutMaps) {
+                      warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.');
+                    }
+                    didWarnAboutMaps = true;
+                  }
+                }
+                var iterator = iteratorFn.call(iterableChildren);
+                var step;
+                var ii = 0;
+                while (!(step = iterator.next()).done) {
+                  child = step.value;
+                  nextName = nextNamePrefix + getElementKey(child, ii++);
+                  subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+                }
+              } else if (type === 'object') {
+                // eslint-disable-next-line react-internal/safe-string-coercion
+                var childrenString = String(children);
+                throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+              }
+            }
+            return subtreeCount;
+          }
+
+          /**
+           * Maps children that are typically specified as `props.children`.
+           *
+           * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+           *
+           * The provided mapFunction(child, index) will be called for each
+           * leaf child.
+           *
+           * @param {?*} children Children tree container.
+           * @param {function(*, int)} func The map function.
+           * @param {*} context Context for mapFunction.
+           * @return {object} Object containing the ordered map of results.
+           */
+          function mapChildren(children, func, context) {
+            if (children == null) {
+              return children;
+            }
+            var result = [];
+            var count = 0;
+            mapIntoArray(children, result, '', '', function (child) {
+              return func.call(context, child, count++);
+            });
+            return result;
+          }
+          /**
+           * Count the number of children that are typically specified as
+           * `props.children`.
+           *
+           * See https://reactjs.org/docs/react-api.html#reactchildrencount
+           *
+           * @param {?*} children Children tree container.
+           * @return {number} The number of children.
+           */
+
+          function countChildren(children) {
+            var n = 0;
+            mapChildren(children, function () {
+              n++; // Don't return anything
+            });
+            return n;
+          }
+
+          /**
+           * Iterates through children that are typically specified as `props.children`.
+           *
+           * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+           *
+           * The provided forEachFunc(child, index) will be called for each
+           * leaf child.
+           *
+           * @param {?*} children Children tree container.
+           * @param {function(*, int)} forEachFunc
+           * @param {*} forEachContext Context for forEachContext.
+           */
+          function forEachChildren(children, forEachFunc, forEachContext) {
+            mapChildren(children, function () {
+              forEachFunc.apply(this, arguments); // Don't return anything.
+            }, forEachContext);
+          }
+          /**
+           * Flatten a children object (typically specified as `props.children`) and
+           * return an array with appropriately re-keyed children.
+           *
+           * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+           */
+
+          function toArray(children) {
+            return mapChildren(children, function (child) {
+              return child;
+            }) || [];
+          }
+          /**
+           * Returns the first child in a collection of children and verifies that there
+           * is only one child in the collection.
+           *
+           * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+           *
+           * The current implementation of this function assumes that a single child gets
+           * passed without a wrapper, but the purpose of this helper function is to
+           * abstract away the particular structure of children.
+           *
+           * @param {?object} children Child collection structure.
+           * @return {ReactElement} The first and only `ReactElement` contained in the
+           * structure.
+           */
+
+          function onlyChild(children) {
+            if (!isValidElement(children)) {
+              throw new Error('React.Children.only expected to receive a single React element child.');
+            }
+            return children;
+          }
+          function createContext(defaultValue) {
+            // TODO: Second argument used to be an optional `calculateChangedBits`
+            // function. Warn to reserve for future use?
+            var context = {
+              $$typeof: REACT_CONTEXT_TYPE,
+              // As a workaround to support multiple concurrent renderers, we categorize
+              // some renderers as primary and others as secondary. We only expect
+              // there to be two concurrent renderers at most: React Native (primary) and
+              // Fabric (secondary); React DOM (primary) and React ART (secondary).
+              // Secondary renderers store their context values on separate fields.
+              _currentValue: defaultValue,
+              _currentValue2: defaultValue,
+              // Used to track how many concurrent renderers this context currently
+              // supports within in a single renderer. Such as parallel server rendering.
+              _threadCount: 0,
+              // These are circular
+              Provider: null,
+              Consumer: null,
+              // Add these to use same hidden class in VM as ServerContext
+              _defaultValue: null,
+              _globalName: null
+            };
+            context.Provider = {
+              $$typeof: REACT_PROVIDER_TYPE,
+              _context: context
+            };
+            var hasWarnedAboutUsingNestedContextConsumers = false;
+            var hasWarnedAboutUsingConsumerProvider = false;
+            var hasWarnedAboutDisplayNameOnConsumer = false;
+            {
+              // A separate object, but proxies back to the original context object for
+              // backwards compatibility. It has a different $$typeof, so we can properly
+              // warn for the incorrect usage of Context as a Consumer.
+              var Consumer = {
+                $$typeof: REACT_CONTEXT_TYPE,
+                _context: context
+              }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
+
+              Object.defineProperties(Consumer, {
+                Provider: {
+                  get: function () {
+                    if (!hasWarnedAboutUsingConsumerProvider) {
+                      hasWarnedAboutUsingConsumerProvider = true;
+                      error('Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?');
+                    }
+                    return context.Provider;
+                  },
+                  set: function (_Provider) {
+                    context.Provider = _Provider;
+                  }
+                },
+                _currentValue: {
+                  get: function () {
+                    return context._currentValue;
+                  },
+                  set: function (_currentValue) {
+                    context._currentValue = _currentValue;
+                  }
+                },
+                _currentValue2: {
+                  get: function () {
+                    return context._currentValue2;
+                  },
+                  set: function (_currentValue2) {
+                    context._currentValue2 = _currentValue2;
+                  }
+                },
+                _threadCount: {
+                  get: function () {
+                    return context._threadCount;
+                  },
+                  set: function (_threadCount) {
+                    context._threadCount = _threadCount;
+                  }
+                },
+                Consumer: {
+                  get: function () {
+                    if (!hasWarnedAboutUsingNestedContextConsumers) {
+                      hasWarnedAboutUsingNestedContextConsumers = true;
+                      error('Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?');
+                    }
+                    return context.Consumer;
+                  }
+                },
+                displayName: {
+                  get: function () {
+                    return context.displayName;
+                  },
+                  set: function (displayName) {
+                    if (!hasWarnedAboutDisplayNameOnConsumer) {
+                      warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName);
+                      hasWarnedAboutDisplayNameOnConsumer = true;
+                    }
+                  }
+                }
+              }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
+
+              context.Consumer = Consumer;
+            }
+            {
+              context._currentRenderer = null;
+              context._currentRenderer2 = null;
+            }
+            return context;
+          }
+          var Uninitialized = -1;
+          var Pending = 0;
+          var Resolved = 1;
+          var Rejected = 2;
+          function lazyInitializer(payload) {
+            if (payload._status === Uninitialized) {
+              var ctor = payload._result;
+              var thenable = ctor(); // Transition to the next state.
+              // This might throw either because it's missing or throws. If so, we treat it
+              // as still uninitialized and try again next time. Which is the same as what
+              // happens if the ctor or any wrappers processing the ctor throws. This might
+              // end up fixing it if the resolution was a concurrency bug.
+
+              thenable.then(function (moduleObject) {
+                if (payload._status === Pending || payload._status === Uninitialized) {
+                  // Transition to the next state.
+                  var resolved = payload;
+                  resolved._status = Resolved;
+                  resolved._result = moduleObject;
+                }
+              }, function (error) {
+                if (payload._status === Pending || payload._status === Uninitialized) {
+                  // Transition to the next state.
+                  var rejected = payload;
+                  rejected._status = Rejected;
+                  rejected._result = error;
+                }
+              });
+              if (payload._status === Uninitialized) {
+                // In case, we're still uninitialized, then we're waiting for the thenable
+                // to resolve. Set it as pending in the meantime.
+                var pending = payload;
+                pending._status = Pending;
+                pending._result = thenable;
+              }
+            }
+            if (payload._status === Resolved) {
+              var moduleObject = payload._result;
+              {
+                if (moduleObject === undefined) {
+                  error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' +
+                  // Break up imports to avoid accidentally parsing them as dependencies.
+                  'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject);
+                }
+              }
+              {
+                if (!('default' in moduleObject)) {
+                  error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' +
+                  // Break up imports to avoid accidentally parsing them as dependencies.
+                  'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject);
+                }
+              }
+              return moduleObject.default;
+            } else {
+              throw payload._result;
+            }
+          }
+          function lazy(ctor) {
+            var payload = {
+              // We use these fields to store the result.
+              _status: Uninitialized,
+              _result: ctor
+            };
+            var lazyType = {
+              $$typeof: REACT_LAZY_TYPE,
+              _payload: payload,
+              _init: lazyInitializer
+            };
+            {
+              // In production, this would just set it on the object.
+              var defaultProps;
+              var propTypes; // $FlowFixMe
+
+              Object.defineProperties(lazyType, {
+                defaultProps: {
+                  configurable: true,
+                  get: function () {
+                    return defaultProps;
+                  },
+                  set: function (newDefaultProps) {
+                    error('React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+                    defaultProps = newDefaultProps; // Match production behavior more closely:
+                    // $FlowFixMe
+
+                    Object.defineProperty(lazyType, 'defaultProps', {
+                      enumerable: true
+                    });
+                  }
+                },
+                propTypes: {
+                  configurable: true,
+                  get: function () {
+                    return propTypes;
+                  },
+                  set: function (newPropTypes) {
+                    error('React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+                    propTypes = newPropTypes; // Match production behavior more closely:
+                    // $FlowFixMe
+
+                    Object.defineProperty(lazyType, 'propTypes', {
+                      enumerable: true
+                    });
+                  }
+                }
+              });
+            }
+            return lazyType;
+          }
+          function forwardRef(render) {
+            {
+              if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
+                error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
+              } else if (typeof render !== 'function') {
+                error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
+              } else {
+                if (render.length !== 0 && render.length !== 2) {
+                  error('forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.');
+                }
+              }
+              if (render != null) {
+                if (render.defaultProps != null || render.propTypes != null) {
+                  error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?');
+                }
+              }
+            }
+            var elementType = {
+              $$typeof: REACT_FORWARD_REF_TYPE,
+              render: render
+            };
+            {
+              var ownName;
+              Object.defineProperty(elementType, 'displayName', {
+                enumerable: false,
+                configurable: true,
+                get: function () {
+                  return ownName;
+                },
+                set: function (name) {
+                  ownName = name; // The inner component shouldn't inherit this display name in most cases,
+                  // because the component may be used elsewhere.
+                  // But it's nice for anonymous functions to inherit the name,
+                  // so that our component-stack generation logic will display their frames.
+                  // An anonymous function generally suggests a pattern like:
+                  //   React.forwardRef((props, ref) => {...});
+                  // This kind of inner function is not used elsewhere so the side effect is okay.
+
+                  if (!render.name && !render.displayName) {
+                    render.displayName = name;
+                  }
+                }
+              });
+            }
+            return elementType;
+          }
+          var REACT_MODULE_REFERENCE;
+          {
+            REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+          }
+          function isValidElementType(type) {
+            if (typeof type === 'string' || typeof type === 'function') {
+              return true;
+            } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+            if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
+              return true;
+            }
+            if (typeof type === 'object' && type !== null) {
+              if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE ||
+              // This needs to include all possible module reference object
+              // types supported by any Flight configuration anywhere since
+              // we don't know which Flight build this will end up being used
+              // with.
+              type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+                return true;
+              }
+            }
+            return false;
+          }
+          function memo(type, compare) {
+            {
+              if (!isValidElementType(type)) {
+                error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
+              }
+            }
+            var elementType = {
+              $$typeof: REACT_MEMO_TYPE,
+              type: type,
+              compare: compare === undefined ? null : compare
+            };
+            {
+              var ownName;
+              Object.defineProperty(elementType, 'displayName', {
+                enumerable: false,
+                configurable: true,
+                get: function () {
+                  return ownName;
+                },
+                set: function (name) {
+                  ownName = name; // The inner component shouldn't inherit this display name in most cases,
+                  // because the component may be used elsewhere.
+                  // But it's nice for anonymous functions to inherit the name,
+                  // so that our component-stack generation logic will display their frames.
+                  // An anonymous function generally suggests a pattern like:
+                  //   React.memo((props) => {...});
+                  // This kind of inner function is not used elsewhere so the side effect is okay.
+
+                  if (!type.name && !type.displayName) {
+                    type.displayName = name;
+                  }
+                }
+              });
+            }
+            return elementType;
+          }
+          function resolveDispatcher() {
+            var dispatcher = ReactCurrentDispatcher.current;
+            {
+              if (dispatcher === null) {
+                error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+              }
+            } // Will result in a null access error if accessed outside render phase. We
+            // intentionally don't throw our own error because this is in a hot path.
+            // Also helps ensure this is inlined.
+
+            return dispatcher;
+          }
+          function useContext(Context) {
+            var dispatcher = resolveDispatcher();
+            {
+              // TODO: add a more generic warning for invalid values.
+              if (Context._context !== undefined) {
+                var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
+                // and nobody should be using this in existing code.
+
+                if (realContext.Consumer === Context) {
+                  error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
+                } else if (realContext.Provider === Context) {
+                  error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
+                }
+              }
+            }
+            return dispatcher.useContext(Context);
+          }
+          function useState(initialState) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useState(initialState);
+          }
+          function useReducer(reducer, initialArg, init) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useReducer(reducer, initialArg, init);
+          }
+          function useRef(initialValue) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useRef(initialValue);
+          }
+          function useEffect(create, deps) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useEffect(create, deps);
+          }
+          function useInsertionEffect(create, deps) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useInsertionEffect(create, deps);
+          }
+          function useLayoutEffect(create, deps) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useLayoutEffect(create, deps);
+          }
+          function useCallback(callback, deps) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useCallback(callback, deps);
+          }
+          function useMemo(create, deps) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useMemo(create, deps);
+          }
+          function useImperativeHandle(ref, create, deps) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useImperativeHandle(ref, create, deps);
+          }
+          function useDebugValue(value, formatterFn) {
+            {
+              var dispatcher = resolveDispatcher();
+              return dispatcher.useDebugValue(value, formatterFn);
+            }
+          }
+          function useTransition() {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useTransition();
+          }
+          function useDeferredValue(value) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useDeferredValue(value);
+          }
+          function useId() {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useId();
+          }
+          function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+            var dispatcher = resolveDispatcher();
+            return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+          }
+
+          // Helpers to patch console.logs to avoid logging during side-effect free
+          // replaying on render function. This currently only patches the object
+          // lazily which won't cover if the log function was extracted eagerly.
+          // We could also eagerly patch the method.
+          var disabledDepth = 0;
+          var prevLog;
+          var prevInfo;
+          var prevWarn;
+          var prevError;
+          var prevGroup;
+          var prevGroupCollapsed;
+          var prevGroupEnd;
+          function disabledLog() {}
+          disabledLog.__reactDisabledLog = true;
+          function disableLogs() {
+            {
+              if (disabledDepth === 0) {
+                /* eslint-disable react-internal/no-production-logging */
+                prevLog = console.log;
+                prevInfo = console.info;
+                prevWarn = console.warn;
+                prevError = console.error;
+                prevGroup = console.group;
+                prevGroupCollapsed = console.groupCollapsed;
+                prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+                var props = {
+                  configurable: true,
+                  enumerable: true,
+                  value: disabledLog,
+                  writable: true
+                }; // $FlowFixMe Flow thinks console is immutable.
+
+                Object.defineProperties(console, {
+                  info: props,
+                  log: props,
+                  warn: props,
+                  error: props,
+                  group: props,
+                  groupCollapsed: props,
+                  groupEnd: props
+                });
+                /* eslint-enable react-internal/no-production-logging */
+              }
+              disabledDepth++;
+            }
+          }
+          function reenableLogs() {
+            {
+              disabledDepth--;
+              if (disabledDepth === 0) {
+                /* eslint-disable react-internal/no-production-logging */
+                var props = {
+                  configurable: true,
+                  enumerable: true,
+                  writable: true
+                }; // $FlowFixMe Flow thinks console is immutable.
+
+                Object.defineProperties(console, {
+                  log: assign({}, props, {
+                    value: prevLog
+                  }),
+                  info: assign({}, props, {
+                    value: prevInfo
+                  }),
+                  warn: assign({}, props, {
+                    value: prevWarn
+                  }),
+                  error: assign({}, props, {
+                    value: prevError
+                  }),
+                  group: assign({}, props, {
+                    value: prevGroup
+                  }),
+                  groupCollapsed: assign({}, props, {
+                    value: prevGroupCollapsed
+                  }),
+                  groupEnd: assign({}, props, {
+                    value: prevGroupEnd
+                  })
+                });
+                /* eslint-enable react-internal/no-production-logging */
+              }
+              if (disabledDepth < 0) {
+                error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+              }
+            }
+          }
+          var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+          var prefix;
+          function describeBuiltInComponentFrame(name, source, ownerFn) {
+            {
+              if (prefix === undefined) {
+                // Extract the VM specific prefix used by each line.
+                try {
+                  throw Error();
+                } catch (x) {
+                  var match = x.stack.trim().match(/\n( *(at )?)/);
+                  prefix = match && match[1] || '';
+                }
+              } // We use the prefix to ensure our stacks line up with native stack frames.
+
+              return '\n' + prefix + name;
+            }
+          }
+          var reentry = false;
+          var componentFrameCache;
+          {
+            var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+            componentFrameCache = new PossiblyWeakMap();
+          }
+          function describeNativeComponentFrame(fn, construct) {
+            // If something asked for a stack inside a fake render, it should get ignored.
+            if (!fn || reentry) {
+              return '';
+            }
+            {
+              var frame = componentFrameCache.get(fn);
+              if (frame !== undefined) {
+                return frame;
+              }
+            }
+            var control;
+            reentry = true;
+            var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
+
+            Error.prepareStackTrace = undefined;
+            var previousDispatcher;
+            {
+              previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
+              // for warnings.
+
+              ReactCurrentDispatcher$1.current = null;
+              disableLogs();
+            }
+            try {
+              // This should throw.
+              if (construct) {
+                // Something should be setting the props in the constructor.
+                var Fake = function () {
+                  throw Error();
+                }; // $FlowFixMe
+
+                Object.defineProperty(Fake.prototype, 'props', {
+                  set: function () {
+                    // We use a throwing setter instead of frozen or non-writable props
+                    // because that won't throw in a non-strict mode function.
+                    throw Error();
+                  }
+                });
+                if (typeof Reflect === 'object' && Reflect.construct) {
+                  // We construct a different control for this case to include any extra
+                  // frames added by the construct call.
+                  try {
+                    Reflect.construct(Fake, []);
+                  } catch (x) {
+                    control = x;
+                  }
+                  Reflect.construct(fn, [], Fake);
+                } else {
+                  try {
+                    Fake.call();
+                  } catch (x) {
+                    control = x;
+                  }
+                  fn.call(Fake.prototype);
+                }
+              } else {
+                try {
+                  throw Error();
+                } catch (x) {
+                  control = x;
+                }
+                fn();
+              }
+            } catch (sample) {
+              // This is inlined manually because closure doesn't do it for us.
+              if (sample && control && typeof sample.stack === 'string') {
+                // This extracts the first frame from the sample that isn't also in the control.
+                // Skipping one frame that we assume is the frame that calls the two.
+                var sampleLines = sample.stack.split('\n');
+                var controlLines = control.stack.split('\n');
+                var s = sampleLines.length - 1;
+                var c = controlLines.length - 1;
+                while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+                  // We expect at least one stack frame to be shared.
+                  // Typically this will be the root most one. However, stack frames may be
+                  // cut off due to maximum stack limits. In this case, one maybe cut off
+                  // earlier than the other. We assume that the sample is longer or the same
+                  // and there for cut off earlier. So we should find the root most frame in
+                  // the sample somewhere in the control.
+                  c--;
+                }
+                for (; s >= 1 && c >= 0; s--, c--) {
+                  // Next we find the first one that isn't the same which should be the
+                  // frame that called our sample function and the control.
+                  if (sampleLines[s] !== controlLines[c]) {
+                    // In V8, the first line is describing the message but other VMs don't.
+                    // If we're about to return the first line, and the control is also on the same
+                    // line, that's a pretty good indicator that our sample threw at same line as
+                    // the control. I.e. before we entered the sample frame. So we ignore this result.
+                    // This can happen if you passed a class to function component, or non-function.
+                    if (s !== 1 || c !== 1) {
+                      do {
+                        s--;
+                        c--; // We may still have similar intermediate frames from the construct call.
+                        // The next one that isn't the same should be our match though.
+
+                        if (c < 0 || sampleLines[s] !== controlLines[c]) {
+                          // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
+                          var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
+                          // but we have a user-provided "displayName"
+                          // splice it in to make the stack more readable.
+
+                          if (fn.displayName && _frame.includes('<anonymous>')) {
+                            _frame = _frame.replace('<anonymous>', fn.displayName);
+                          }
+                          {
+                            if (typeof fn === 'function') {
+                              componentFrameCache.set(fn, _frame);
+                            }
+                          } // Return the line we found.
+
+                          return _frame;
+                        }
+                      } while (s >= 1 && c >= 0);
+                    }
+                    break;
+                  }
+                }
+              }
+            } finally {
+              reentry = false;
+              {
+                ReactCurrentDispatcher$1.current = previousDispatcher;
+                reenableLogs();
+              }
+              Error.prepareStackTrace = previousPrepareStackTrace;
+            } // Fallback to just using the name if we couldn't make it throw.
+
+            var name = fn ? fn.displayName || fn.name : '';
+            var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+            {
+              if (typeof fn === 'function') {
+                componentFrameCache.set(fn, syntheticFrame);
+              }
+            }
+            return syntheticFrame;
+          }
+          function describeFunctionComponentFrame(fn, source, ownerFn) {
+            {
+              return describeNativeComponentFrame(fn, false);
+            }
+          }
+          function shouldConstruct(Component) {
+            var prototype = Component.prototype;
+            return !!(prototype && prototype.isReactComponent);
+          }
+          function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+            if (type == null) {
+              return '';
+            }
+            if (typeof type === 'function') {
+              {
+                return describeNativeComponentFrame(type, shouldConstruct(type));
+              }
+            }
+            if (typeof type === 'string') {
+              return describeBuiltInComponentFrame(type);
+            }
+            switch (type) {
+              case REACT_SUSPENSE_TYPE:
+                return describeBuiltInComponentFrame('Suspense');
+              case REACT_SUSPENSE_LIST_TYPE:
+                return describeBuiltInComponentFrame('SuspenseList');
+            }
+            if (typeof type === 'object') {
+              switch (type.$$typeof) {
+                case REACT_FORWARD_REF_TYPE:
+                  return describeFunctionComponentFrame(type.render);
+                case REACT_MEMO_TYPE:
+                  // Memo may contain any component type so we recursively resolve it.
+                  return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
+                case REACT_LAZY_TYPE:
+                  {
+                    var lazyComponent = type;
+                    var payload = lazyComponent._payload;
+                    var init = lazyComponent._init;
+                    try {
+                      // Lazy may contain any component type so we recursively resolve it.
+                      return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
+                    } catch (x) {}
+                  }
+              }
+            }
+            return '';
+          }
+          var loggedTypeFailures = {};
+          var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+          function setCurrentlyValidatingElement(element) {
+            {
+              if (element) {
+                var owner = element._owner;
+                var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+                ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+              } else {
+                ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+              }
+            }
+          }
+          function checkPropTypes(typeSpecs, values, location, componentName, element) {
+            {
+              // $FlowFixMe This is okay but Flow doesn't know it.
+              var has = Function.call.bind(hasOwnProperty);
+              for (var typeSpecName in typeSpecs) {
+                if (has(typeSpecs, typeSpecName)) {
+                  var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+                  // fail the render phase where it didn't fail before. So we log it.
+                  // After these have been cleaned up, we'll let them throw.
+
+                  try {
+                    // This is intentionally an invariant that gets caught. It's the same
+                    // behavior as without this statement except with a better message.
+                    if (typeof typeSpecs[typeSpecName] !== 'function') {
+                      // eslint-disable-next-line react-internal/prod-error-codes
+                      var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
+                      err.name = 'Invariant Violation';
+                      throw err;
+                    }
+                    error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
+                  } catch (ex) {
+                    error$1 = ex;
+                  }
+                  if (error$1 && !(error$1 instanceof Error)) {
+                    setCurrentlyValidatingElement(element);
+                    error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
+                    setCurrentlyValidatingElement(null);
+                  }
+                  if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+                    // Only monitor this failure once because there tends to be a lot of the
+                    // same error.
+                    loggedTypeFailures[error$1.message] = true;
+                    setCurrentlyValidatingElement(element);
+                    error('Failed %s type: %s', location, error$1.message);
+                    setCurrentlyValidatingElement(null);
+                  }
+                }
+              }
+            }
+          }
+          function setCurrentlyValidatingElement$1(element) {
+            {
+              if (element) {
+                var owner = element._owner;
+                var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
+                setExtraStackFrame(stack);
+              } else {
+                setExtraStackFrame(null);
+              }
+            }
+          }
+          var propTypesMisspellWarningShown;
+          {
+            propTypesMisspellWarningShown = false;
+          }
+          function getDeclarationErrorAddendum() {
+            if (ReactCurrentOwner.current) {
+              var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+              if (name) {
+                return '\n\nCheck the render method of `' + name + '`.';
+              }
+            }
+            return '';
+          }
+          function getSourceInfoErrorAddendum(source) {
+            if (source !== undefined) {
+              var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+              var lineNumber = source.lineNumber;
+              return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
+            }
+            return '';
+          }
+          function getSourceInfoErrorAddendumForProps(elementProps) {
+            if (elementProps !== null && elementProps !== undefined) {
+              return getSourceInfoErrorAddendum(elementProps.__source);
+            }
+            return '';
+          }
+          /**
+           * Warn if there's no key explicitly set on dynamic arrays of children or
+           * object keys are not valid. This allows us to keep track of children between
+           * updates.
+           */
+
+          var ownerHasKeyUseWarning = {};
+          function getCurrentComponentErrorInfo(parentType) {
+            var info = getDeclarationErrorAddendum();
+            if (!info) {
+              var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
+              if (parentName) {
+                info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+              }
+            }
+            return info;
+          }
+          /**
+           * Warn if the element doesn't have an explicit key assigned to it.
+           * This element is in an array. The array could grow and shrink or be
+           * reordered. All children that haven't already been validated are required to
+           * have a "key" property assigned to it. Error statuses are cached so a warning
+           * will only be shown once.
+           *
+           * @internal
+           * @param {ReactElement} element Element that requires a key.
+           * @param {*} parentType element's parent's type.
+           */
+
+          function validateExplicitKey(element, parentType) {
+            if (!element._store || element._store.validated || element.key != null) {
+              return;
+            }
+            element._store.validated = true;
+            var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+            if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+              return;
+            }
+            ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+            // property, it may be the creator of the child that's responsible for
+            // assigning it a key.
+
+            var childOwner = '';
+            if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+              // Give the component that originally created this child.
+              childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+            }
+            {
+              setCurrentlyValidatingElement$1(element);
+              error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
+              setCurrentlyValidatingElement$1(null);
+            }
+          }
+          /**
+           * Ensure that every element either is passed in a static location, in an
+           * array with an explicit keys property defined, or in an object literal
+           * with valid key property.
+           *
+           * @internal
+           * @param {ReactNode} node Statically passed child of any type.
+           * @param {*} parentType node's parent's type.
+           */
+
+          function validateChildKeys(node, parentType) {
+            if (typeof node !== 'object') {
+              return;
+            }
+            if (isArray(node)) {
+              for (var i = 0; i < node.length; i++) {
+                var child = node[i];
+                if (isValidElement(child)) {
+                  validateExplicitKey(child, parentType);
+                }
+              }
+            } else if (isValidElement(node)) {
+              // This element was passed in a valid location.
+              if (node._store) {
+                node._store.validated = true;
+              }
+            } else if (node) {
+              var iteratorFn = getIteratorFn(node);
+              if (typeof iteratorFn === 'function') {
+                // Entry iterators used to provide implicit keys,
+                // but now we print a separate warning for them later.
+                if (iteratorFn !== node.entries) {
+                  var iterator = iteratorFn.call(node);
+                  var step;
+                  while (!(step = iterator.next()).done) {
+                    if (isValidElement(step.value)) {
+                      validateExplicitKey(step.value, parentType);
+                    }
+                  }
+                }
+              }
+            }
+          }
+          /**
+           * Given an element, validate that its props follow the propTypes definition,
+           * provided by the type.
+           *
+           * @param {ReactElement} element
+           */
+
+          function validatePropTypes(element) {
+            {
+              var type = element.type;
+              if (type === null || type === undefined || typeof type === 'string') {
+                return;
+              }
+              var propTypes;
+              if (typeof type === 'function') {
+                propTypes = type.propTypes;
+              } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE ||
+              // Note: Memo only checks outer props here.
+              // Inner props are checked in the reconciler.
+              type.$$typeof === REACT_MEMO_TYPE)) {
+                propTypes = type.propTypes;
+              } else {
+                return;
+              }
+              if (propTypes) {
+                // Intentionally inside to avoid triggering lazy initializers:
+                var name = getComponentNameFromType(type);
+                checkPropTypes(propTypes, element.props, 'prop', name, element);
+              } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+                propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
+
+                var _name = getComponentNameFromType(type);
+                error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
+              }
+              if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
+                error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
+              }
+            }
+          }
+          /**
+           * Given a fragment, validate that it can only be provided with fragment props
+           * @param {ReactElement} fragment
+           */
+
+          function validateFragmentProps(fragment) {
+            {
+              var keys = Object.keys(fragment.props);
+              for (var i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                if (key !== 'children' && key !== 'key') {
+                  setCurrentlyValidatingElement$1(fragment);
+                  error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+                  setCurrentlyValidatingElement$1(null);
+                  break;
+                }
+              }
+              if (fragment.ref !== null) {
+                setCurrentlyValidatingElement$1(fragment);
+                error('Invalid attribute `ref` supplied to `React.Fragment`.');
+                setCurrentlyValidatingElement$1(null);
+              }
+            }
+          }
+          function createElementWithValidation(type, props, children) {
+            var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+            // succeed and there will likely be errors in render.
+
+            if (!validType) {
+              var info = '';
+              if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+                info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
+              }
+              var sourceInfo = getSourceInfoErrorAddendumForProps(props);
+              if (sourceInfo) {
+                info += sourceInfo;
+              } else {
+                info += getDeclarationErrorAddendum();
+              }
+              var typeString;
+              if (type === null) {
+                typeString = 'null';
+              } else if (isArray(type)) {
+                typeString = 'array';
+              } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+                typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+                info = ' Did you accidentally export a JSX literal instead of a component?';
+              } else {
+                typeString = typeof type;
+              }
+              {
+                error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+              }
+            }
+            var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
+            // TODO: Drop this when these are no longer allowed as the type argument.
+
+            if (element == null) {
+              return element;
+            } // Skip key warning if the type isn't valid since our key validation logic
+            // doesn't expect a non-string/function type and can throw confusing errors.
+            // We don't want exception behavior to differ between dev and prod.
+            // (Rendering will throw with a helpful message and as soon as the type is
+            // fixed, the key warnings will appear.)
+
+            if (validType) {
+              for (var i = 2; i < arguments.length; i++) {
+                validateChildKeys(arguments[i], type);
+              }
+            }
+            if (type === REACT_FRAGMENT_TYPE) {
+              validateFragmentProps(element);
+            } else {
+              validatePropTypes(element);
+            }
+            return element;
+          }
+          var didWarnAboutDeprecatedCreateFactory = false;
+          function createFactoryWithValidation(type) {
+            var validatedFactory = createElementWithValidation.bind(null, type);
+            validatedFactory.type = type;
+            {
+              if (!didWarnAboutDeprecatedCreateFactory) {
+                didWarnAboutDeprecatedCreateFactory = true;
+                warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.');
+              } // Legacy hook: remove it
+
+              Object.defineProperty(validatedFactory, 'type', {
+                enumerable: false,
+                get: function () {
+                  warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+                  Object.defineProperty(this, 'type', {
+                    value: type
+                  });
+                  return type;
+                }
+              });
+            }
+            return validatedFactory;
+          }
+          function cloneElementWithValidation(element, props, children) {
+            var newElement = cloneElement.apply(this, arguments);
+            for (var i = 2; i < arguments.length; i++) {
+              validateChildKeys(arguments[i], newElement.type);
+            }
+            validatePropTypes(newElement);
+            return newElement;
+          }
+          function startTransition(scope, options) {
+            var prevTransition = ReactCurrentBatchConfig.transition;
+            ReactCurrentBatchConfig.transition = {};
+            var currentTransition = ReactCurrentBatchConfig.transition;
+            {
+              ReactCurrentBatchConfig.transition._updatedFibers = new Set();
+            }
+            try {
+              scope();
+            } finally {
+              ReactCurrentBatchConfig.transition = prevTransition;
+              {
+                if (prevTransition === null && currentTransition._updatedFibers) {
+                  var updatedFibersCount = currentTransition._updatedFibers.size;
+                  if (updatedFibersCount > 10) {
+                    warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.');
+                  }
+                  currentTransition._updatedFibers.clear();
+                }
+              }
+            }
+          }
+          var didWarnAboutMessageChannel = false;
+          var enqueueTaskImpl = null;
+          function enqueueTask(task) {
+            if (enqueueTaskImpl === null) {
+              try {
+                // read require off the module object to get around the bundlers.
+                // we don't want them to detect a require and bundle a Node polyfill.
+                var requireString = ('require' + Math.random()).slice(0, 7);
+                var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
+                // version of setImmediate, bypassing fake timers if any.
+
+                enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
+              } catch (_err) {
+                // we're in a browser
+                // we can't use regular timers because they may still be faked
+                // so we try MessageChannel+postMessage instead
+                enqueueTaskImpl = function (callback) {
+                  {
+                    if (didWarnAboutMessageChannel === false) {
+                      didWarnAboutMessageChannel = true;
+                      if (typeof MessageChannel === 'undefined') {
+                        error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
+                      }
+                    }
+                  }
+                  var channel = new MessageChannel();
+                  channel.port1.onmessage = callback;
+                  channel.port2.postMessage(undefined);
+                };
+              }
+            }
+            return enqueueTaskImpl(task);
+          }
+          var actScopeDepth = 0;
+          var didWarnNoAwaitAct = false;
+          function act(callback) {
+            {
+              // `act` calls can be nested, so we track the depth. This represents the
+              // number of `act` scopes on the stack.
+              var prevActScopeDepth = actScopeDepth;
+              actScopeDepth++;
+              if (ReactCurrentActQueue.current === null) {
+                // This is the outermost `act` scope. Initialize the queue. The reconciler
+                // will detect the queue and use it instead of Scheduler.
+                ReactCurrentActQueue.current = [];
+              }
+              var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
+              var result;
+              try {
+                // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
+                // set to `true` while the given callback is executed, not for updates
+                // triggered during an async event, because this is how the legacy
+                // implementation of `act` behaved.
+                ReactCurrentActQueue.isBatchingLegacy = true;
+                result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
+                // which flushed updates immediately after the scope function exits, even
+                // if it's an async function.
+
+                if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
+                  var queue = ReactCurrentActQueue.current;
+                  if (queue !== null) {
+                    ReactCurrentActQueue.didScheduleLegacyUpdate = false;
+                    flushActQueue(queue);
+                  }
+                }
+              } catch (error) {
+                popActScope(prevActScopeDepth);
+                throw error;
+              } finally {
+                ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
+              }
+              if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
+                var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
+                // for it to resolve before exiting the current scope.
+
+                var wasAwaited = false;
+                var thenable = {
+                  then: function (resolve, reject) {
+                    wasAwaited = true;
+                    thenableResult.then(function (returnValue) {
+                      popActScope(prevActScopeDepth);
+                      if (actScopeDepth === 0) {
+                        // We've exited the outermost act scope. Recursively flush the
+                        // queue until there's no remaining work.
+                        recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                      } else {
+                        resolve(returnValue);
+                      }
+                    }, function (error) {
+                      // The callback threw an error.
+                      popActScope(prevActScopeDepth);
+                      reject(error);
+                    });
+                  }
+                };
+                {
+                  if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {
+                    // eslint-disable-next-line no-undef
+                    Promise.resolve().then(function () {}).then(function () {
+                      if (!wasAwaited) {
+                        didWarnNoAwaitAct = true;
+                        error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');
+                      }
+                    });
+                  }
+                }
+                return thenable;
+              } else {
+                var returnValue = result; // The callback is not an async function. Exit the current scope
+                // immediately, without awaiting.
+
+                popActScope(prevActScopeDepth);
+                if (actScopeDepth === 0) {
+                  // Exiting the outermost act scope. Flush the queue.
+                  var _queue = ReactCurrentActQueue.current;
+                  if (_queue !== null) {
+                    flushActQueue(_queue);
+                    ReactCurrentActQueue.current = null;
+                  } // Return a thenable. If the user awaits it, we'll flush again in
+                  // case additional work was scheduled by a microtask.
+
+                  var _thenable = {
+                    then: function (resolve, reject) {
+                      // Confirm we haven't re-entered another `act` scope, in case
+                      // the user does something weird like await the thenable
+                      // multiple times.
+                      if (ReactCurrentActQueue.current === null) {
+                        // Recursively flush the queue until there's no remaining work.
+                        ReactCurrentActQueue.current = [];
+                        recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                      } else {
+                        resolve(returnValue);
+                      }
+                    }
+                  };
+                  return _thenable;
+                } else {
+                  // Since we're inside a nested `act` scope, the returned thenable
+                  // immediately resolves. The outer scope will flush the queue.
+                  var _thenable2 = {
+                    then: function (resolve, reject) {
+                      resolve(returnValue);
+                    }
+                  };
+                  return _thenable2;
+                }
+              }
+            }
+          }
+          function popActScope(prevActScopeDepth) {
+            {
+              if (prevActScopeDepth !== actScopeDepth - 1) {
+                error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
+              }
+              actScopeDepth = prevActScopeDepth;
+            }
+          }
+          function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+            {
+              var queue = ReactCurrentActQueue.current;
+              if (queue !== null) {
+                try {
+                  flushActQueue(queue);
+                  enqueueTask(function () {
+                    if (queue.length === 0) {
+                      // No additional work was scheduled. Finish.
+                      ReactCurrentActQueue.current = null;
+                      resolve(returnValue);
+                    } else {
+                      // Keep flushing work until there's none left.
+                      recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                    }
+                  });
+                } catch (error) {
+                  reject(error);
+                }
+              } else {
+                resolve(returnValue);
+              }
+            }
+          }
+          var isFlushing = false;
+          function flushActQueue(queue) {
+            {
+              if (!isFlushing) {
+                // Prevent re-entrance.
+                isFlushing = true;
+                var i = 0;
+                try {
+                  for (; i < queue.length; i++) {
+                    var callback = queue[i];
+                    do {
+                      callback = callback(true);
+                    } while (callback !== null);
+                  }
+                  queue.length = 0;
+                } catch (error) {
+                  // If something throws, leave the remaining callbacks on the queue.
+                  queue = queue.slice(i + 1);
+                  throw error;
+                } finally {
+                  isFlushing = false;
+                }
+              }
+            }
+          }
+          var createElement$1 = createElementWithValidation;
+          var cloneElement$1 = cloneElementWithValidation;
+          var createFactory = createFactoryWithValidation;
+          var Children = {
+            map: mapChildren,
+            forEach: forEachChildren,
+            count: countChildren,
+            toArray: toArray,
+            only: onlyChild
+          };
+          exports.Children = Children;
+          exports.Component = Component;
+          exports.Fragment = REACT_FRAGMENT_TYPE;
+          exports.Profiler = REACT_PROFILER_TYPE;
+          exports.PureComponent = PureComponent;
+          exports.StrictMode = REACT_STRICT_MODE_TYPE;
+          exports.Suspense = REACT_SUSPENSE_TYPE;
+          exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
+          exports.act = act;
+          exports.cloneElement = cloneElement$1;
+          exports.createContext = createContext;
+          exports.createElement = createElement$1;
+          exports.createFactory = createFactory;
+          exports.createRef = createRef;
+          exports.forwardRef = forwardRef;
+          exports.isValidElement = isValidElement;
+          exports.lazy = lazy;
+          exports.memo = memo;
+          exports.startTransition = startTransition;
+          exports.unstable_act = act;
+          exports.useCallback = useCallback;
+          exports.useContext = useContext;
+          exports.useDebugValue = useDebugValue;
+          exports.useDeferredValue = useDeferredValue;
+          exports.useEffect = useEffect;
+          exports.useId = useId;
+          exports.useImperativeHandle = useImperativeHandle;
+          exports.useInsertionEffect = useInsertionEffect;
+          exports.useLayoutEffect = useLayoutEffect;
+          exports.useMemo = useMemo;
+          exports.useReducer = useReducer;
+          exports.useRef = useRef;
+          exports.useState = useState;
+          exports.useSyncExternalStore = useSyncExternalStore;
+          exports.useTransition = useTransition;
+          exports.version = ReactVersion;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+          if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === 'function') {
+            __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+          }
+        })();
+      }
+    })(react_development, react_development.exports);
+    return react_development.exports;
+  }
+
+  (function (module) {
+
+    if (process.env.NODE_ENV === 'production') {
+      module.exports = requireReact_production_min();
+    } else {
+      module.exports = requireReact_development();
+    }
+  })(react);
+
+  var useAction = function useAction(action, deps) {
+    return useActions([action], deps)[0];
+  };
+  var useActions = function useActions(actions, deps) {
+    var dispatch = reactRedux.useDispatch();
+    return react.exports.useMemo(function () {
+      if (Array.isArray(actions)) {
+        return actions.map(function (a) {
+          return bindActionCreators(a, dispatch);
+        });
+      }
+      return bindActionCreators(actions, dispatch);
+    }, /* eslint-disable-next-line react-hooks/exhaustive-deps */
+    deps ? [dispatch].concat(_toConsumableArray(deps)) : [dispatch]);
+  };
+
+  var asyncReducers = {}; // placeholder for injected reducers
+
+  var injectReducer = function injectReducer(store) {
+    var staticReducers = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var key = arguments.length > 2 ? arguments[2] : undefined;
+    var asyncReducer = arguments.length > 3 ? arguments[3] : undefined;
+    if (!asyncReducers[key]) {
+      asyncReducers[key] = asyncReducer;
+      store.replaceReducer(combineReducers(_objectSpread2$1(_objectSpread2$1({}, staticReducers), asyncReducers)));
+    }
+  };
+  var injectSlice = function injectSlice(store, staticReducers, slice) {
+    return injectReducer(store, staticReducers, slice.name, slice.reducer);
+  };
+  var getSetterActionName = function getSetterActionName(name) {
+    return "set".concat(upperFirst_1(name));
+  };
+  var makeSetterReducersFromInitialState = function makeSetterReducersFromInitialState(initialState, config, pluginsData) {
+    var reducer = {};
+    Object.keys(initialState).forEach(function (name) {
+      var key = getSetterActionName(name);
+      reducer[key] = function (state, action) {
+        var value = action.payload;
+        pluginsData[name].forEach(function (_ref) {
+          var data = _ref.data,
+            plugin = _ref.plugin;
+          value = plugin.update(value, _objectSpread2$1({
+            state: state,
+            config: plugin.config,
+            draft: state
+          }, data)); // provide both state. and draft. apis so fewer users complain
+        });
+        state[name] = value;
+      };
+    });
+    return reducer;
+  };
+
+  /* eslint-enable react/forbid-foreign-prop-types */
+
+  var plugin = function plugin(_ref) {
+    var constructorFn = _ref.constructor,
+      setup = _ref.setup,
+      getInitialValue = _ref.getInitialValue,
+      update = _ref.update,
+      _ref$config = _ref.config,
+      config = _ref$config === void 0 ? {} : _ref$config;
+    return /*#__PURE__*/function () {
+      function _class(value) {
+        _classCallCheck(this, _class);
+        this.value = value;
+        this.setup = setup || this.setup;
+        this.getInitialValue = getInitialValue || this.getInitialValue;
+        this.update = update || this.update;
+        this.config = config;
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        constructorFn === null || constructorFn === void 0 || constructorFn.call.apply(constructorFn, [this, value].concat(args));
+      }
+
+      // either the initial state value or the next plugin
+      return _createClass(_class, [{
+        key: "getValue",
+        value: function getValue() {
+          return this.value;
+        }
+      }, {
+        key: "setValue",
+        value: function setValue(value) {
+          this.value = value;
+        }
+      }, {
+        key: "setConfig",
+        value: function setConfig(config) {
+          this.config = _objectSpread2$1(_objectSpread2$1({}, this.config), config);
+        }
+      }, {
+        key: "setup",
+        value: function setup(item, _ref2) {
+          _objectDestructuringEmpty(_ref2);
+          return {
+            plugin: item
+          };
+        }
+      }, {
+        key: "getInitialValue",
+        value: function getInitialValue(value, _ref3) {
+          _objectDestructuringEmpty(_ref3);
+          return value;
+        }
+      }, {
+        key: "update",
+        value: function update(value, _ref4) {
+          _objectDestructuringEmpty(_ref4);
+          return value;
+        }
+      }]);
+    }();
+  };
+  var addPlugin = function addPlugin(config) {
+    var Class = plugin(config);
+    plugins.push(Class);
+    return function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return _construct(Class, args);
+    };
+  };
+  var addPlugins = function addPlugins() {
+    for (var _len3 = arguments.length, configs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      configs[_key3] = arguments[_key3];
+    }
+    return configs.map(addPlugin);
+  };
+  var plugins = [];
+
+  var makeSelectorHook = function makeSelectorHook(selector) {
+    return function () {
+      return reactRedux.useSelector(selector, reactRedux.shallowEqual);
+    };
+  };
+  var createSelectorUpdateHook = function createSelectorUpdateHook(selector, action) {
+    return function () {
+      return [reactRedux.useSelector(selector), useAction(action, undefined)];
+    };
+  };
+  var createSelectorHook = function createSelectorHook() {
+    // creates a redux selector and a react hook that produce identical results
+    var selector = createDraftSafeSelector.apply(void 0, arguments);
+    var hook = makeSelectorHook(selector);
+    hook.select = selector;
+    return hook;
+  };
+  var configure$1 = function configure(store) {
+    var makeDomainSelector = function makeDomainSelector(name, initialState) {
+      return function (state) {
+        return (state === null || state === void 0 ? void 0 : state[name]) || initialState;
+      };
+    };
+    var makeDomainSelectorFromSlice = function makeDomainSelectorFromSlice(slice) {
+      return makeDomainSelector(slice.name, slice.getInitialState());
+    };
+    var selectProp = function selectProp(name, defaultValue) {
+      return function (substate) {
+        return get_1(substate, name, defaultValue);
+      };
+    };
+    var makePropertySelectorHookFactory = function makePropertySelectorHookFactory(baseSelector, slice) {
+      return function (names) {
+        // to be used in conjunction with singlePropReducer to mimic the useState api,
+        //  but for individual pieces of redux state rather than component state
         // usage:
         //  selector.js:
         //   const selectDomain = state => state?.[domain] || initialState;
@@ -6057,7 +8787,6 @@
         useAction(slice.actions.__override__slice__caution, undefined) // state overwriter
         ];
       };
-
       hooks[domainHookKey].select = selectDomain;
       hooks[domainHookKey].update = updateFn;
       /* eslint-enable react-hooks/rules-of-hooks */