impact-ui 4.0.17 → 4.0.18-alpha.1

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/build/stringEndsWith.js

@@ -0,0 +1,53 @@
+import { __exports as stringEndsWith } from "../../../../../_virtual/stringEndsWith.js";
+import { __require as requirePropTypes } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredStringEndsWith;
+function requireStringEndsWith() {
+  if (hasRequiredStringEndsWith) return stringEndsWith;
+  hasRequiredStringEndsWith = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = stringEndsWithValidator;
+    var _propTypes = requirePropTypes();
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function stringEndsWithValidator(end) {
+      if (typeof end !== "string" || end.length === 0) {
+        throw new TypeError("a non-empty string is required");
+      }
+      var validator = function stringEndsWith2(props, propName, componentName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+          rest[_key - 3] = arguments[_key];
+        }
+        var stringError = _propTypes.string.apply(void 0, [props, propName, componentName].concat(rest));
+        if (stringError) {
+          return stringError;
+        }
+        if (!propValue.endsWith(end) || propValue.length <= end.length) {
+          return new TypeError("".concat(componentName, ": ").concat(propName, ' does not end with "').concat(end, '"'));
+        }
+        return null;
+      };
+      validator.isRequired = function requiredStringEndsWith() {
+        var stringError = _propTypes.string.isRequired.apply(_propTypes.string, arguments);
+        if (stringError) {
+          return stringError;
+        }
+        return validator.apply(void 0, arguments);
+      };
+      return (0, _wrapValidator["default"])(validator, "stringEndsWith: ".concat(end));
+    }
+  })(stringEndsWith);
+  return stringEndsWith;
+}
+export {
+  requireStringEndsWith as __require
+};

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/build/stringStartsWith.js

@@ -0,0 +1,53 @@
+import { __exports as stringStartsWith } from "../../../../../_virtual/stringStartsWith.js";
+import { __require as requirePropTypes } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredStringStartsWith;
+function requireStringStartsWith() {
+  if (hasRequiredStringStartsWith) return stringStartsWith;
+  hasRequiredStringStartsWith = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = stringStartsWithValidator;
+    var _propTypes = requirePropTypes();
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function stringStartsWithValidator(start) {
+      if (typeof start !== "string" || start.length === 0) {
+        throw new TypeError("a non-empty string is required");
+      }
+      var validator = function stringStartsWith2(props, propName, componentName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+          rest[_key - 3] = arguments[_key];
+        }
+        var stringError = _propTypes.string.apply(void 0, [props, propName, componentName].concat(rest));
+        if (stringError) {
+          return stringError;
+        }
+        if (!propValue.startsWith(start) || propValue.length <= start.length) {
+          return new TypeError("".concat(componentName, ": ").concat(propName, ' does not start with "').concat(start, '"'));
+        }
+        return null;
+      };
+      validator.isRequired = function requiredStringStartsWith() {
+        var stringError = _propTypes.string.isRequired.apply(_propTypes.string, arguments);
+        if (stringError) {
+          return stringError;
+        }
+        return validator.apply(void 0, arguments);
+      };
+      return (0, _wrapValidator["default"])(validator, "stringStartsWith: ".concat(start));
+    }
+  })(stringStartsWith);
+  return stringStartsWith;
+}
+export {
+  requireStringStartsWith as __require
+};

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/build/uniqueArray.js

@@ -0,0 +1,69 @@
+import { __exports as uniqueArray } from "../../../../../_virtual/uniqueArray.js";
+import { __require as requirePropTypes } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredUniqueArray;
+function requireUniqueArray() {
+  if (hasRequiredUniqueArray) return uniqueArray;
+  hasRequiredUniqueArray = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _propTypes = requirePropTypes();
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function uniqueCountWithSet(arr) {
+      return new Set(arr).size;
+    }
+    function uniqueCountLegacy(arr) {
+      var seen = [];
+      arr.forEach(function(item) {
+        if (seen.indexOf(item) === -1) {
+          seen.push(item);
+        }
+      });
+      return seen.length;
+    }
+    var getUniqueCount = typeof Set === "function" ? uniqueCountWithSet : (
+      /* istanbul ignore next */
+      uniqueCountLegacy
+    );
+    function requiredUniqueArray(props, propName, componentName) {
+      for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+        rest[_key - 3] = arguments[_key];
+      }
+      var result = _propTypes.array.isRequired.apply(_propTypes.array, [props, propName, componentName].concat(rest));
+      if (result != null) {
+        return result;
+      }
+      var propValue = props[propName];
+      var uniqueCount = getUniqueCount(propValue);
+      if (uniqueCount !== propValue.length) {
+        return new RangeError("".concat(componentName, ": values must be unique. ").concat(propValue.length - uniqueCount, " duplicate values found."));
+      }
+      return null;
+    }
+    function uniqueArray2(props, propName) {
+      var propValue = props[propName];
+      if (propValue == null) {
+        return null;
+      }
+      for (var _len2 = arguments.length, rest = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        rest[_key2 - 2] = arguments[_key2];
+      }
+      return requiredUniqueArray.apply(void 0, [props, propName].concat(rest));
+    }
+    uniqueArray2.isRequired = requiredUniqueArray;
+    var _default = function _default2() {
+      return (0, _wrapValidator["default"])(uniqueArray2, "uniqueArray");
+    };
+    exports["default"] = _default;
+  })(uniqueArray);
+  return uniqueArray;
+}
+export {
+  requireUniqueArray as __require
+};

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/build/uniqueArrayOf.js

@@ -0,0 +1,116 @@
+import { __exports as uniqueArrayOf } from "../../../../../_virtual/uniqueArrayOf.js";
+import { __require as requirePropTypes } from "../../../../prop-types/index.js";
+import { __require as requireAnd } from "./and.js";
+import { __require as requireUniqueArray } from "./uniqueArray.js";
+var hasRequiredUniqueArrayOf;
+function requireUniqueArrayOf() {
+  if (hasRequiredUniqueArrayOf) return uniqueArrayOf;
+  hasRequiredUniqueArrayOf = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = uniqueArrayOfTypeValidator;
+    var _propTypes = requirePropTypes();
+    var _and = _interopRequireDefault(requireAnd());
+    var _uniqueArray = _interopRequireDefault(requireUniqueArray());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+        keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        if (i % 2) {
+          ownKeys(Object(source), true).forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+          });
+        } else if (Object.getOwnPropertyDescriptors) {
+          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+        } else {
+          ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+          });
+        }
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var unique = (0, _uniqueArray["default"])();
+    function uniqueArrayOfTypeValidator(type) {
+      if (typeof type !== "function") {
+        throw new TypeError("type must be a validator function");
+      }
+      var mapper = null;
+      var name = "uniqueArrayOfType";
+      for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        rest[_key - 1] = arguments[_key];
+      }
+      if (rest.length === 1) {
+        if (typeof rest[0] === "function") {
+          mapper = rest[0];
+        } else if (typeof rest[0] === "string") {
+          name = rest[0];
+        } else {
+          throw new TypeError("single input must either be string or function");
+        }
+      } else if (rest.length === 2) {
+        if (typeof rest[0] === "function" && typeof rest[1] === "string") {
+          mapper = rest[0];
+          name = rest[1];
+        } else {
+          throw new TypeError("multiple inputs must be in [function, string] order");
+        }
+      } else if (rest.length > 2) {
+        throw new TypeError("only [], [name], [mapper], and [mapper, name] are valid inputs");
+      }
+      function uniqueArrayOfMapped(props, propName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        var values = propValue.map(mapper);
+        for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+          args[_key2 - 2] = arguments[_key2];
+        }
+        return unique.apply(void 0, [_objectSpread(_objectSpread({}, props), {}, _defineProperty({}, propName, values)), propName].concat(args));
+      }
+      uniqueArrayOfMapped.isRequired = function isRequired(props, propName) {
+        var propValue = props[propName];
+        for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+          args[_key3 - 2] = arguments[_key3];
+        }
+        if (propValue == null) {
+          return _propTypes.array.isRequired.apply(_propTypes.array, [props, propName].concat(args));
+        }
+        return uniqueArrayOfMapped.apply(void 0, [props, propName].concat(args));
+      };
+      var arrayValidator = (0, _propTypes.arrayOf)(type);
+      var uniqueValidator = mapper ? uniqueArrayOfMapped : unique;
+      var validator = (0, _and["default"])([arrayValidator, uniqueValidator], name);
+      validator.isRequired = (0, _and["default"])([uniqueValidator.isRequired, arrayValidator.isRequired], "".concat(name, ".isRequired"));
+      return validator;
+    }
+  })(uniqueArrayOf);
+  return uniqueArrayOf;
+}
+export {
+  requireUniqueArrayOf as __require
+};

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/build/valuesOf.js

@@ -0,0 +1,54 @@
+import { __exports as valuesOf } from "../../../../../_virtual/valuesOf.js";
+import { __require as requireIsPrimitive } from "./helpers/isPrimitive.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredValuesOf;
+function requireValuesOf() {
+  if (hasRequiredValuesOf) return valuesOf;
+  hasRequiredValuesOf = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = valuesOfValidator;
+    var _isPrimitive = _interopRequireDefault(requireIsPrimitive());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function valuesOfValidator(propType) {
+      if (typeof propType !== "function") {
+        throw new TypeError("objectOf: propType must be a function");
+      }
+      var validator = function valuesOf2(props, propName, componentName, location, propFullName) {
+        for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
+          rest[_key - 5] = arguments[_key];
+        }
+        var propValue = props[propName];
+        if (propValue == null || (0, _isPrimitive["default"])(propValue)) {
+          return null;
+        }
+        var firstError;
+        Object.keys(propValue).some(function(key) {
+          firstError = propType.apply(void 0, [propValue, key, componentName, location, "".concat(propFullName, ".").concat(key)].concat(rest));
+          return firstError;
+        });
+        return firstError || null;
+      };
+      validator.isRequired = function valuesOfRequired(props, propName, componentName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return new TypeError("".concat(componentName, ": ").concat(propName, " is required."));
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return validator.apply(void 0, [props, propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(validator, "valuesOf", propType);
+    }
+  })(valuesOf);
+  return valuesOf;
+}
+export {
+  requireValuesOf as __require
+};

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/build/withShape.js

@@ -0,0 +1,30 @@
+import { __exports as withShape } from "../../../../../_virtual/withShape.js";
+import { __require as requireAnd } from "./and.js";
+import { __require as requireShape } from "./shape.js";
+var hasRequiredWithShape;
+function requireWithShape() {
+  if (hasRequiredWithShape) return withShape;
+  hasRequiredWithShape = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = withShape2;
+    var _and = _interopRequireDefault(requireAnd());
+    var _shape = _interopRequireDefault(requireShape());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function withShape2(type, shapeTypes) {
+      if (typeof type !== "function") {
+        throw new TypeError("type must be a valid PropType");
+      }
+      var shapeValidator = (0, _shape["default"])(shapeTypes);
+      return (0, _and["default"])([type, shapeValidator], "withShape");
+    }
+  })(withShape);
+  return withShape;
+}
+export {
+  requireWithShape as __require
+};

package/dist/node_modules/react-dates/node_modules/airbnb-prop-types/index.js

@@ -0,0 +1,13 @@
+import { __require as requireMocks } from "./build/mocks/index.js";
+import { __require as requireBuild } from "./build/index.js";
+var airbnbPropTypes;
+var hasRequiredAirbnbPropTypes;
+function requireAirbnbPropTypes() {
+  if (hasRequiredAirbnbPropTypes) return airbnbPropTypes;
+  hasRequiredAirbnbPropTypes = 1;
+  airbnbPropTypes = process.env.NODE_ENV === "production" ? requireMocks() : requireBuild();
+  return airbnbPropTypes;
+}
+export {
+  requireAirbnbPropTypes as __require
+};

package/dist/node_modules/react-is/cjs/react-is.development.js

@@ -1,9 +1,8 @@
-import { __exports as reactIs_development } from "../../../_virtual/react-is.development.js";
-/**
- * @license React
+import { __exports as reactIs_development } from "../../../_virtual/react-is2.development.js";
+/** @license React v16.13.1
  * react-is.development.js
  *
- * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * 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.
@@ -12,92 +11,153 @@ var hasRequiredReactIs_development;
 function requireReactIs_development() {
   if (hasRequiredReactIs_development) return reactIs_development;
   hasRequiredReactIs_development = 1;
-  "production" !== process.env.NODE_ENV && function() {
-    function typeOf(object) {
-      if ("object" === typeof object && null !== object) {
-        var $$typeof = object.$$typeof;
-        switch ($$typeof) {
-          case REACT_ELEMENT_TYPE:
-            switch (object = object.type, object) {
-              case REACT_FRAGMENT_TYPE:
-              case REACT_PROFILER_TYPE:
-              case REACT_STRICT_MODE_TYPE:
-              case REACT_SUSPENSE_TYPE:
-              case REACT_SUSPENSE_LIST_TYPE:
-              case REACT_VIEW_TRANSITION_TYPE:
-                return object;
-              default:
-                switch (object = object && object.$$typeof, object) {
-                  case REACT_CONTEXT_TYPE:
-                  case REACT_FORWARD_REF_TYPE:
-                  case REACT_LAZY_TYPE:
-                  case REACT_MEMO_TYPE:
-                    return object;
-                  case REACT_CONSUMER_TYPE:
-                    return object;
-                  default:
-                    return $$typeof;
-                }
-            }
-          case REACT_PORTAL_TYPE:
-            return $$typeof;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      var hasSymbol = typeof Symbol === "function" && Symbol.for;
+      var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
+      var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
+      var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
+      var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
+      var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
+      var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
+      var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
+      var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
+      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
+      var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
+      var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
+      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
+      var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
+      var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
+      var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
+      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
+      var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
+      var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
+      function isValidElementType(type) {
+        return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+        type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (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 || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+      }
+      function typeOf(object) {
+        if (typeof object === "object" && object !== null) {
+          var $$typeof = object.$$typeof;
+          switch ($$typeof) {
+            case REACT_ELEMENT_TYPE:
+              var type = object.type;
+              switch (type) {
+                case REACT_ASYNC_MODE_TYPE:
+                case REACT_CONCURRENT_MODE_TYPE:
+                case REACT_FRAGMENT_TYPE:
+                case REACT_PROFILER_TYPE:
+                case REACT_STRICT_MODE_TYPE:
+                case REACT_SUSPENSE_TYPE:
+                  return type;
+                default:
+                  var $$typeofType = type && type.$$typeof;
+                  switch ($$typeofType) {
+                    case REACT_CONTEXT_TYPE:
+                    case REACT_FORWARD_REF_TYPE:
+                    case REACT_LAZY_TYPE:
+                    case REACT_MEMO_TYPE:
+                    case REACT_PROVIDER_TYPE:
+                      return $$typeofType;
+                    default:
+                      return $$typeof;
+                  }
+              }
+            case REACT_PORTAL_TYPE:
+              return $$typeof;
+          }
+        }
+        return void 0;
+      }
+      var AsyncMode = REACT_ASYNC_MODE_TYPE;
+      var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+      var ContextConsumer = REACT_CONTEXT_TYPE;
+      var ContextProvider = REACT_PROVIDER_TYPE;
+      var Element = REACT_ELEMENT_TYPE;
+      var ForwardRef = REACT_FORWARD_REF_TYPE;
+      var Fragment = REACT_FRAGMENT_TYPE;
+      var Lazy = REACT_LAZY_TYPE;
+      var Memo = REACT_MEMO_TYPE;
+      var Portal = REACT_PORTAL_TYPE;
+      var Profiler = REACT_PROFILER_TYPE;
+      var StrictMode = REACT_STRICT_MODE_TYPE;
+      var Suspense = REACT_SUSPENSE_TYPE;
+      var hasWarnedAboutDeprecatedIsAsyncMode = false;
+      function isAsyncMode(object) {
+        {
+          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+            hasWarnedAboutDeprecatedIsAsyncMode = true;
+            console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
+          }
         }
+        return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+      }
+      function isConcurrentMode(object) {
+        return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+      }
+      function isContextConsumer(object) {
+        return typeOf(object) === REACT_CONTEXT_TYPE;
+      }
+      function isContextProvider(object) {
+        return typeOf(object) === REACT_PROVIDER_TYPE;
+      }
+      function isElement(object) {
+        return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function isForwardRef(object) {
+        return typeOf(object) === REACT_FORWARD_REF_TYPE;
+      }
+      function isFragment(object) {
+        return typeOf(object) === REACT_FRAGMENT_TYPE;
+      }
+      function isLazy(object) {
+        return typeOf(object) === REACT_LAZY_TYPE;
+      }
+      function isMemo(object) {
+        return typeOf(object) === REACT_MEMO_TYPE;
+      }
+      function isPortal(object) {
+        return typeOf(object) === REACT_PORTAL_TYPE;
+      }
+      function isProfiler(object) {
+        return typeOf(object) === REACT_PROFILER_TYPE;
+      }
+      function isStrictMode(object) {
+        return typeOf(object) === REACT_STRICT_MODE_TYPE;
+      }
+      function isSuspense(object) {
+        return typeOf(object) === REACT_SUSPENSE_TYPE;
       }
-    }
-    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
-    reactIs_development.ContextConsumer = REACT_CONSUMER_TYPE;
-    reactIs_development.ContextProvider = REACT_CONTEXT_TYPE;
-    reactIs_development.Element = REACT_ELEMENT_TYPE;
-    reactIs_development.ForwardRef = REACT_FORWARD_REF_TYPE;
-    reactIs_development.Fragment = REACT_FRAGMENT_TYPE;
-    reactIs_development.Lazy = REACT_LAZY_TYPE;
-    reactIs_development.Memo = REACT_MEMO_TYPE;
-    reactIs_development.Portal = REACT_PORTAL_TYPE;
-    reactIs_development.Profiler = REACT_PROFILER_TYPE;
-    reactIs_development.StrictMode = REACT_STRICT_MODE_TYPE;
-    reactIs_development.Suspense = REACT_SUSPENSE_TYPE;
-    reactIs_development.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
-    reactIs_development.isContextConsumer = function(object) {
-      return typeOf(object) === REACT_CONSUMER_TYPE;
-    };
-    reactIs_development.isContextProvider = function(object) {
-      return typeOf(object) === REACT_CONTEXT_TYPE;
-    };
-    reactIs_development.isElement = function(object) {
-      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
-    };
-    reactIs_development.isForwardRef = function(object) {
-      return typeOf(object) === REACT_FORWARD_REF_TYPE;
-    };
-    reactIs_development.isFragment = function(object) {
-      return typeOf(object) === REACT_FRAGMENT_TYPE;
-    };
-    reactIs_development.isLazy = function(object) {
-      return typeOf(object) === REACT_LAZY_TYPE;
-    };
-    reactIs_development.isMemo = function(object) {
-      return typeOf(object) === REACT_MEMO_TYPE;
-    };
-    reactIs_development.isPortal = function(object) {
-      return typeOf(object) === REACT_PORTAL_TYPE;
-    };
-    reactIs_development.isProfiler = function(object) {
-      return typeOf(object) === REACT_PROFILER_TYPE;
-    };
-    reactIs_development.isStrictMode = function(object) {
-      return typeOf(object) === REACT_STRICT_MODE_TYPE;
-    };
-    reactIs_development.isSuspense = function(object) {
-      return typeOf(object) === REACT_SUSPENSE_TYPE;
-    };
-    reactIs_development.isSuspenseList = function(object) {
-      return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
-    };
-    reactIs_development.isValidElementType = function(type) {
-      return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
-    };
-    reactIs_development.typeOf = typeOf;
-  }();
+      reactIs_development.AsyncMode = AsyncMode;
+      reactIs_development.ConcurrentMode = ConcurrentMode;
+      reactIs_development.ContextConsumer = ContextConsumer;
+      reactIs_development.ContextProvider = ContextProvider;
+      reactIs_development.Element = Element;
+      reactIs_development.ForwardRef = ForwardRef;
+      reactIs_development.Fragment = Fragment;
+      reactIs_development.Lazy = Lazy;
+      reactIs_development.Memo = Memo;
+      reactIs_development.Portal = Portal;
+      reactIs_development.Profiler = Profiler;
+      reactIs_development.StrictMode = StrictMode;
+      reactIs_development.Suspense = Suspense;
+      reactIs_development.isAsyncMode = isAsyncMode;
+      reactIs_development.isConcurrentMode = isConcurrentMode;
+      reactIs_development.isContextConsumer = isContextConsumer;
+      reactIs_development.isContextProvider = isContextProvider;
+      reactIs_development.isElement = isElement;
+      reactIs_development.isForwardRef = isForwardRef;
+      reactIs_development.isFragment = isFragment;
+      reactIs_development.isLazy = isLazy;
+      reactIs_development.isMemo = isMemo;
+      reactIs_development.isPortal = isPortal;
+      reactIs_development.isProfiler = isProfiler;
+      reactIs_development.isStrictMode = isStrictMode;
+      reactIs_development.isSuspense = isSuspense;
+      reactIs_development.isValidElementType = isValidElementType;
+      reactIs_development.typeOf = typeOf;
+    })();
+  }
   return reactIs_development;
 }
 export {

package/dist/node_modules/{prop-types/node_modules/react-is → react-is}/cjs/react-is.production.min.js

@@ -1,4 +1,4 @@
-import { __exports as reactIs_production_min } from "../../../../../_virtual/react-is.production.min.js";
+import { __exports as reactIs_production_min } from "../../../_virtual/react-is2.production.min.js";
 /** @license React v16.13.1
  * react-is.production.min.js
  *