impact-ui 4.0.16 → 4.0.17-alpha.2

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

@@ -0,0 +1,65 @@
+import { __exports as childrenHavePropXorChildren } from "../../../../../_virtual/childrenHavePropXorChildren.js";
+import React__default from "react";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredChildrenHavePropXorChildren;
+function requireChildrenHavePropXorChildren() {
+  if (hasRequiredChildrenHavePropXorChildren) return childrenHavePropXorChildren;
+  hasRequiredChildrenHavePropXorChildren = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = childrenHavePropXorChildren2;
+    var _react = _interopRequireDefault(React__default);
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    function childrenHavePropXorChildren2(prop) {
+      if (typeof prop !== "string" && _typeof(prop) !== "symbol") {
+        throw new TypeError("invalid prop: must be string or symbol");
+      }
+      var validator = function childrenHavePropXorChildrenWithProp(_ref, _, componentName) {
+        var children = _ref.children;
+        var truthyChildrenCount = 0;
+        var propCount = 0;
+        var grandchildrenCount = 0;
+        _react["default"].Children.forEach(children, function(child) {
+          if (!child) {
+            return;
+          }
+          truthyChildrenCount += 1;
+          if (child.props[prop]) {
+            propCount += 1;
+          }
+          if (_react["default"].Children.count(child.props.children)) {
+            grandchildrenCount += 1;
+          }
+        });
+        if (propCount === truthyChildrenCount && grandchildrenCount === 0 || propCount === 0 && grandchildrenCount === truthyChildrenCount || propCount === 0 && grandchildrenCount === 0) {
+          return null;
+        }
+        return new TypeError("`".concat(componentName, "` requires children to all have prop “").concat(prop, "”, all have children, or all have neither."));
+      };
+      validator.isRequired = validator;
+      return (0, _wrapValidator["default"])(validator, "childrenHavePropXorChildrenWithProp:".concat(prop), prop);
+    }
+  })(childrenHavePropXorChildren);
+  return childrenHavePropXorChildren;
+}
+export {
+  requireChildrenHavePropXorChildren as __require
+};

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

@@ -0,0 +1,105 @@
+import { __exports as childrenOf } from "../../../../../_virtual/childrenOf.js";
+import { __require as requireRenderableChildren } from "./helpers/renderableChildren.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredChildrenOf;
+function requireChildrenOf() {
+  if (hasRequiredChildrenOf) return childrenOf;
+  hasRequiredChildrenOf = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = childrenOf2;
+    var _renderableChildren = _interopRequireDefault(requireRenderableChildren());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    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;
+    }
+    function validateChildren(propType, children, props) {
+      for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+        rest[_key - 3] = arguments[_key];
+      }
+      var error;
+      children.some(function(child) {
+        error = propType.apply(void 0, [_objectSpread(_objectSpread({}, props), {}, {
+          children: child
+        }), "children"].concat(rest));
+        return error;
+      });
+      return error || null;
+    }
+    function childrenOf2(propType) {
+      function childrenOfPropType(props, propName, componentName) {
+        if (propName !== "children") {
+          return new TypeError("".concat(componentName, ' is using the childrenOf validator on non-children prop "').concat(propName, '"'));
+        }
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        var children = (0, _renderableChildren["default"])(propValue);
+        if (children.length === 0) {
+          return null;
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return validateChildren.apply(void 0, [propType, children, props, componentName].concat(rest));
+      }
+      childrenOfPropType.isRequired = function(props, propName, componentName) {
+        if (propName !== "children") {
+          return new TypeError("".concat(componentName, ' is using the childrenOf validator on non-children prop "').concat(propName, '"'));
+        }
+        var children = (0, _renderableChildren["default"])(props[propName]);
+        if (children.length === 0) {
+          return new TypeError("`".concat(componentName, "` requires at least one node of type ").concat(propType.typeName || propType.name));
+        }
+        for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
+          rest[_key3 - 3] = arguments[_key3];
+        }
+        return validateChildren.apply(void 0, [propType, children, props, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(childrenOfPropType, "childrenOf", propType);
+    }
+  })(childrenOf);
+  return childrenOf;
+}
+export {
+  requireChildrenOf as __require
+};

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

@@ -0,0 +1,63 @@
+import { __exports as childrenOfType } from "../../../../../_virtual/childrenOfType.js";
+import { __require as requireArray_prototype_find } from "../../../../array.prototype.find/index.js";
+import { __require as requireGetComponentName } from "./helpers/getComponentName.js";
+import { __require as requireRenderableChildren } from "./helpers/renderableChildren.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredChildrenOfType;
+function requireChildrenOfType() {
+  if (hasRequiredChildrenOfType) return childrenOfType;
+  hasRequiredChildrenOfType = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _arrayPrototype = _interopRequireDefault(requireArray_prototype_find());
+    var _getComponentName = _interopRequireDefault(requireGetComponentName());
+    var _renderableChildren = _interopRequireDefault(requireRenderableChildren());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function onlyTypes(types, children, componentName) {
+      if (!children.every(function(child) {
+        return child && (0, _arrayPrototype["default"])(types, function(Type) {
+          return Type === "*" || child.type === Type;
+        });
+      })) {
+        var typeNames = types.map(_getComponentName["default"]).join(", or ");
+        return new TypeError("`".concat(componentName, "` only accepts children of type ").concat(typeNames));
+      }
+      return null;
+    }
+    function isRequired(types, children, componentName) {
+      if (children.length === 0) {
+        var typeNames = types.map(_getComponentName["default"]).join(", or ");
+        return new TypeError("`".concat(componentName, "` requires at least one node of type ").concat(typeNames));
+      }
+      return null;
+    }
+    function childrenOfType2() {
+      for (var _len = arguments.length, types = new Array(_len), _key = 0; _key < _len; _key++) {
+        types[_key] = arguments[_key];
+      }
+      if (types.length < 1) {
+        throw new TypeError("childrenOfType: at least 1 type is required");
+      }
+      function validator(props, propName, componentName) {
+        return onlyTypes(types, (0, _renderableChildren["default"])(props[propName]), componentName);
+      }
+      validator.isRequired = function(props, propName, componentName) {
+        var children = (0, _renderableChildren["default"])(props[propName]);
+        return isRequired(types, children, componentName) || onlyTypes(types, children, componentName);
+      };
+      return (0, _wrapValidator["default"])(validator, "childrenOfType", types);
+    }
+    var _default = childrenOfType2;
+    exports["default"] = _default;
+  })(childrenOfType);
+  return childrenOfType;
+}
+export {
+  requireChildrenOfType as __require
+};

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

@@ -0,0 +1,100 @@
+import { __exports as childrenSequenceOf } from "../../../../../_virtual/childrenSequenceOf.js";
+import { __require as requireSequenceOf } from "./sequenceOf.js";
+import { __require as requireRenderableChildren } from "./helpers/renderableChildren.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredChildrenSequenceOf;
+function requireChildrenSequenceOf() {
+  if (hasRequiredChildrenSequenceOf) return childrenSequenceOf;
+  hasRequiredChildrenSequenceOf = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = childrenSequenceOfValidator;
+    var _sequenceOf = _interopRequireDefault(requireSequenceOf());
+    var _renderableChildren = _interopRequireDefault(requireRenderableChildren());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    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;
+    }
+    function childrenSequenceOfValidator() {
+      for (var _len = arguments.length, specifiers = new Array(_len), _key = 0; _key < _len; _key++) {
+        specifiers[_key] = arguments[_key];
+      }
+      var seq = _sequenceOf["default"].apply(void 0, specifiers);
+      var validator = function childrenSequenceOf2(props, propName, componentName) {
+        if (propName !== "children") {
+          return new TypeError("".concat(componentName, ' is using the childrenSequenceOf validator on non-children prop "').concat(propName, '"'));
+        }
+        var propValue = props[propName];
+        var children = (0, _renderableChildren["default"])(propValue);
+        if (children.length === 0) {
+          return null;
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return seq.apply(void 0, [_objectSpread(_objectSpread({}, props), {}, {
+          children
+        }), propName, componentName].concat(rest));
+      };
+      validator.isRequired = function childrenSequenceOfRequired(props, propName, componentName) {
+        if (propName !== "children") {
+          return new TypeError("".concat(componentName, ' is using the childrenSequenceOf validator on non-children prop "').concat(propName, '"'));
+        }
+        var propValue = props[propName];
+        var children = (0, _renderableChildren["default"])(propValue);
+        if (children.length === 0) {
+          return new TypeError("".concat(componentName, ": renderable children are required."));
+        }
+        for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
+          rest[_key3 - 3] = arguments[_key3];
+        }
+        return seq.isRequired.apply(seq, [_objectSpread(_objectSpread({}, props), {}, {
+          children
+        }), propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(validator, "childrenSequenceOf", specifiers);
+    }
+  })(childrenSequenceOf);
+  return childrenSequenceOf;
+}
+export {
+  requireChildrenSequenceOf as __require
+};

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

@@ -0,0 +1,109 @@
+import { __exports as componentWithName } from "../../../../../_virtual/componentWithName.js";
+import React__default from "react";
+import { __require as requireIsRegex } from "../../../../is-regex/index.js";
+import { __require as requireArray_prototype_find } from "../../../../array.prototype.find/index.js";
+import { __require as requireGetComponentName } from "./helpers/getComponentName.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredComponentWithName;
+function requireComponentWithName() {
+  if (hasRequiredComponentWithName) return componentWithName;
+  hasRequiredComponentWithName = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = componentWithName2;
+    var _react = _interopRequireDefault(React__default);
+    var _isRegex = _interopRequireDefault(requireIsRegex());
+    var _arrayPrototype = _interopRequireDefault(requireArray_prototype_find());
+    var _getComponentName = _interopRequireDefault(requireGetComponentName());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function stripHOCs(fullName, namesOfHOCsToStrip) {
+      var innerName = fullName;
+      while (/\([^()]*\)/g.test(innerName)) {
+        var HOC = innerName;
+        var previousHOC = void 0;
+        do {
+          previousHOC = HOC;
+          HOC = previousHOC.replace(/\([^()]*\)/g, "");
+        } while (previousHOC !== HOC);
+        if (namesOfHOCsToStrip.indexOf(HOC) === -1) {
+          return innerName;
+        }
+        innerName = innerName.replace(RegExp("^".concat(HOC, "\\(|\\)$"), "g"), "");
+      }
+      return innerName;
+    }
+    function hasName(name, namesOfHOCsToStrip, propValue, propName, componentName) {
+      for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
+        rest[_key - 5] = arguments[_key];
+      }
+      if (Array.isArray(propValue)) {
+        return (0, _arrayPrototype["default"])(propValue.map(function(item) {
+          return hasName.apply(void 0, [name, namesOfHOCsToStrip, item, propName, componentName].concat(rest));
+        }), Boolean) || null;
+      }
+      if (!/* @__PURE__ */ _react["default"].isValidElement(propValue)) {
+        return new TypeError("".concat(componentName, ".").concat(propName, " is not a valid React element"));
+      }
+      var type = propValue.type;
+      var componentNameFromType = (0, _getComponentName["default"])(type);
+      var innerComponentName = namesOfHOCsToStrip.length > 0 ? stripHOCs(componentNameFromType, namesOfHOCsToStrip) : componentNameFromType;
+      if ((0, _isRegex["default"])(name) && !name.test(innerComponentName)) {
+        return new TypeError("`".concat(componentName, ".").concat(propName, "` only accepts components matching the regular expression ").concat(name));
+      }
+      if (!(0, _isRegex["default"])(name) && innerComponentName !== name) {
+        return new TypeError("`".concat(componentName, ".").concat(propName, "` only accepts components named ").concat(name, ", got ").concat(innerComponentName));
+      }
+      return null;
+    }
+    function componentWithName2(name) {
+      var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      if (typeof name !== "string" && !(0, _isRegex["default"])(name)) {
+        throw new TypeError("name must be a string or a regex");
+      }
+      var passedOptions = Object.keys(options);
+      if (passedOptions.length > 1 || passedOptions.length === 1 && passedOptions[0] !== "stripHOCs") {
+        throw new TypeError("The only options supported are: “stripHOCs”, got: “".concat(passedOptions.join("”, “"), "”"));
+      }
+      var _options$stripHOCs = options.stripHOCs, namesOfHOCsToStrip = _options$stripHOCs === void 0 ? [] : _options$stripHOCs;
+      var allHOCNamesAreValid = namesOfHOCsToStrip.every(function(x) {
+        if (typeof x !== "string" || /[()]/g.test(x)) {
+          return false;
+        }
+        return /^(?:[a-z][a-zA-Z0-9]+|[A-Z][a-z][a-zA-Z0-9]+)$/.test(x);
+      });
+      if (!allHOCNamesAreValid) {
+        throw new TypeError("every provided HOC name must be a string with no parens, and in camelCase");
+      }
+      function componentWithNameValidator(props, propName, componentName) {
+        var propValue = props[propName];
+        if (props[propName] == null) {
+          return null;
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return hasName.apply(void 0, [name, namesOfHOCsToStrip, propValue, propName, componentName].concat(rest));
+      }
+      componentWithNameValidator.isRequired = function componentWithNameRequired(props, propName, componentName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return new TypeError("`".concat(componentName, ".").concat(propName, "` requires at least one component named ").concat(name));
+        }
+        for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
+          rest[_key3 - 3] = arguments[_key3];
+        }
+        return hasName.apply(void 0, [name, namesOfHOCsToStrip, propValue, propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(componentWithNameValidator, "componentWithName:".concat(name), name);
+    }
+  })(componentWithName);
+  return componentWithName;
+}
+export {
+  requireComponentWithName as __require
+};

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

@@ -0,0 +1,64 @@
+import { __exports as disallowedIf } from "../../../../../_virtual/disallowedIf.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredDisallowedIf;
+function requireDisallowedIf() {
+  if (hasRequiredDisallowedIf) return disallowedIf;
+  hasRequiredDisallowedIf = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = disallowedIf2;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function disallowedIf2(propType, otherPropName, otherPropType) {
+      if (typeof propType !== "function" || typeof propType.isRequired !== "function") {
+        throw new TypeError("a propType validator is required; propType validators must also provide `.isRequired`");
+      }
+      if (typeof otherPropName !== "string") {
+        throw new TypeError("other prop name must be a string");
+      }
+      if (typeof otherPropType !== "function") {
+        throw new TypeError("other prop type validator is required");
+      }
+      function disallowedIfRequired(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 error = propType.isRequired.apply(propType, [props, propName, componentName].concat(rest));
+        if (error) {
+          return error;
+        }
+        if (props[otherPropName] == null) {
+          return null;
+        }
+        var otherError = otherPropType.apply(void 0, [props, otherPropName, componentName].concat(rest));
+        if (otherError) {
+          return null;
+        }
+        return new Error("prop “".concat(propName, "” is disallowed when “").concat(otherPropName, "” matches the provided validator"));
+      }
+      var validator = function disallowedIfPropType(props, propName) {
+        if (props[propName] == 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 disallowedIfRequired.apply(void 0, [props, propName].concat(rest));
+      };
+      validator.isRequired = disallowedIfRequired;
+      return (0, _wrapValidator["default"])(validator, "disallowedIf", {
+        propType,
+        otherPropName,
+        otherPropType
+      });
+    }
+  })(disallowedIf);
+  return disallowedIf;
+}
+export {
+  requireDisallowedIf as __require
+};

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

@@ -0,0 +1,77 @@
+import { __exports as elementType } from "../../../../../_virtual/elementType.js";
+import { p as propTypesExports } from "../../../../prop-types/index.js";
+import { __require as requireReactIs } from "../../../../react-is/index.js";
+import { __require as requireAnd } from "./and.js";
+import { __require as requireGetComponentName } from "./helpers/getComponentName.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredElementType;
+function requireElementType() {
+  if (hasRequiredElementType) return elementType;
+  hasRequiredElementType = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = elementTypeValidator;
+    var _propTypes = propTypesExports;
+    var _reactIs = requireReactIs();
+    var _and = _interopRequireDefault(requireAnd());
+    var _getComponentName = _interopRequireDefault(requireGetComponentName());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    function getTypeName(Type) {
+      if (typeof Type === "string") {
+        return Type;
+      }
+      var type = (0, _getComponentName["default"])(Type);
+      return type || "Anonymous Component";
+    }
+    function validateElementType(Type, props, propName, componentName) {
+      var type = props[propName].type;
+      if (type === Type) {
+        return null;
+      }
+      return new TypeError("".concat(componentName, ".").concat(propName, " must be a React element of type ").concat(getTypeName(Type)));
+    }
+    function elementTypeValidator(Type) {
+      if (Type === "*") {
+        return (0, _wrapValidator["default"])(_propTypes.element, "elementType(*)", Type);
+      }
+      if (!(0, _reactIs.isValidElementType)(Type)) {
+        throw new TypeError('Type must be a React Component, an HTML element tag name, or "*". Got an '.concat(_typeof(Type)));
+      }
+      function elementType2(props, propName, componentName) {
+        if (props[propName] == 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];
+        }
+        return validateElementType.apply(void 0, [Type, props, propName, componentName].concat(rest));
+      }
+      elementType2.isRequired = elementType2;
+      var typeName = getTypeName(Type);
+      var validatorName = "elementType(".concat(typeName, ")");
+      return (0, _wrapValidator["default"])((0, _and["default"])([_propTypes.element, elementType2], validatorName), validatorName, Type);
+    }
+  })(elementType);
+  return elementType;
+}
+export {
+  requireElementType as __require
+};

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

@@ -0,0 +1,46 @@
+import { __exports as empty } from "../../../../../_virtual/empty.js";
+import { p as propTypesExports } from "../../../../prop-types/index.js";
+import { __require as requireOr } from "./or.js";
+import { __require as requireExplicitNull } from "./explicitNull.js";
+import { __require as requireWithShape } from "./withShape.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredEmpty;
+function requireEmpty() {
+  if (hasRequiredEmpty) return empty;
+  hasRequiredEmpty = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _propTypes = propTypesExports;
+    var _or = _interopRequireDefault(requireOr());
+    var _explicitNull = _interopRequireDefault(requireExplicitNull());
+    var _withShape = _interopRequireDefault(requireWithShape());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var arrayOfValidator;
+    var validator = (0, _or["default"])([
+      _explicitNull["default"],
+      // null/undefined
+      (0, _propTypes.oneOf)([false, "", NaN]),
+      (0, _withShape["default"])(_propTypes.array, {
+        length: (0, _propTypes.oneOf)([0]).isRequired
+      }).isRequired,
+      function() {
+        return arrayOfValidator.apply(void 0, arguments);
+      }
+    ]);
+    arrayOfValidator = (0, _propTypes.arrayOf)(validator).isRequired;
+    var _default = function _default2() {
+      return (0, _wrapValidator["default"])(validator, "empty");
+    };
+    exports["default"] = _default;
+  })(empty);
+  return empty;
+}
+export {
+  requireEmpty as __require
+};