impact-ui 4.0.16 → 4.0.17-alpha.2

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

@@ -0,0 +1,64 @@
+import { __exports as mutuallyExclusiveTrueProps } from "../../../../../_virtual/mutuallyExclusiveTrueProps.js";
+import { p as propTypesExports } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredMutuallyExclusiveTrueProps;
+function requireMutuallyExclusiveTrueProps() {
+  if (hasRequiredMutuallyExclusiveTrueProps) return mutuallyExclusiveTrueProps;
+  hasRequiredMutuallyExclusiveTrueProps = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = mutuallyExclusiveTrue;
+    var _propTypes = propTypesExports;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function mutuallyExclusiveTrue() {
+      for (var _len = arguments.length, exclusiveProps = new Array(_len), _key = 0; _key < _len; _key++) {
+        exclusiveProps[_key] = arguments[_key];
+      }
+      if (exclusiveProps.length < 1) {
+        throw new TypeError("at least one prop that is mutually exclusive is required");
+      }
+      if (!exclusiveProps.every(function(x) {
+        return typeof x === "string";
+      })) {
+        throw new TypeError("all exclusive true props must be strings");
+      }
+      var propsList = exclusiveProps.join(", or ");
+      var validator = function mutuallyExclusiveTrueProps2(props, propName, componentName) {
+        var countProps = function countProps2(count, prop) {
+          return count + (props[prop] ? 1 : 0);
+        };
+        var exclusivePropCount = exclusiveProps.reduce(countProps, 0);
+        if (exclusivePropCount > 1) {
+          return new Error("A ".concat(componentName, " cannot have more than one of these boolean props be true: ").concat(propsList));
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return _propTypes.bool.apply(void 0, [props, propName, componentName].concat(rest));
+      };
+      validator.isRequired = function mutuallyExclusiveTruePropsRequired(props, propName, componentName) {
+        var countProps = function countProps2(count, prop) {
+          return count + (props[prop] ? 1 : 0);
+        };
+        var exclusivePropCount = exclusiveProps.reduce(countProps, 0);
+        if (exclusivePropCount > 1) {
+          return new Error("A ".concat(componentName, " cannot have more than one of these boolean props be true: ").concat(propsList));
+        }
+        for (var _len3 = arguments.length, rest = new Array(_len3 > 3 ? _len3 - 3 : 0), _key3 = 3; _key3 < _len3; _key3++) {
+          rest[_key3 - 3] = arguments[_key3];
+        }
+        return _propTypes.bool.isRequired.apply(_propTypes.bool, [props, propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(validator, "mutuallyExclusiveTrueProps: ".concat(propsList), exclusiveProps);
+    }
+  })(mutuallyExclusiveTrueProps);
+  return mutuallyExclusiveTrueProps;
+}
+export {
+  requireMutuallyExclusiveTrueProps as __require
+};

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

@@ -0,0 +1,47 @@
+import { __exports as nChildren } from "../../../../../_virtual/nChildren.js";
+import React__default from "react";
+import { p as propTypesExports } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredNChildren;
+function requireNChildren() {
+  if (hasRequiredNChildren) return nChildren;
+  hasRequiredNChildren = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = nChildren2;
+    var _react = _interopRequireDefault(React__default);
+    var _propTypes = propTypesExports;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function nChildren2(n) {
+      var propType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _propTypes.node;
+      if (typeof n !== "number" || isNaN(n) || n < 0) {
+        throw new TypeError("a non-negative number is required");
+      }
+      var validator = function nChildrenValidator(props, propName, componentName) {
+        if (propName !== "children") {
+          return new TypeError("".concat(componentName, " is using the nChildren validator on a non-children prop"));
+        }
+        var children = props.children;
+        var childrenCount = _react["default"].Children.count(children);
+        if (childrenCount !== n) {
+          return new RangeError("".concat(componentName, " expects to receive ").concat(n, " children, but received ").concat(childrenCount, " children."));
+        }
+        for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+          rest[_key - 3] = arguments[_key];
+        }
+        return propType.apply(void 0, [props, propName, componentName].concat(rest));
+      };
+      validator.isRequired = validator;
+      return (0, _wrapValidator["default"])(validator, "nChildren:".concat(n), n);
+    }
+  })(nChildren);
+  return nChildren;
+}
+export {
+  requireNChildren as __require
+};

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

@@ -0,0 +1,27 @@
+import { __exports as nonNegativeInteger } from "../../../../../_virtual/nonNegativeInteger.js";
+import { __require as requireAnd } from "./and.js";
+import { __require as requireInteger } from "./integer.js";
+import { __require as requireNonNegativeNumber } from "./nonNegativeNumber.js";
+var hasRequiredNonNegativeInteger;
+function requireNonNegativeInteger() {
+  if (hasRequiredNonNegativeInteger) return nonNegativeInteger;
+  hasRequiredNonNegativeInteger = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _and = _interopRequireDefault(requireAnd());
+    var _integer = _interopRequireDefault(requireInteger());
+    var _nonNegativeNumber = _interopRequireDefault(requireNonNegativeNumber());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var _default = (0, _and["default"])([(0, _integer["default"])(), (0, _nonNegativeNumber["default"])()], "nonNegativeInteger");
+    exports["default"] = _default;
+  })(nonNegativeInteger);
+  return nonNegativeInteger;
+}
+export {
+  requireNonNegativeInteger as __require
+};

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

@@ -0,0 +1,45 @@
+import { __exports as nonNegativeNumber } from "../../../../../_virtual/nonNegativeNumber.js";
+import { __require as requireObjectIs } from "../../../../object-is/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredNonNegativeNumber;
+function requireNonNegativeNumber() {
+  if (hasRequiredNonNegativeNumber) return nonNegativeNumber;
+  hasRequiredNonNegativeNumber = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _objectIs = _interopRequireDefault(requireObjectIs());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function isNonNegative(x) {
+      return typeof x === "number" && isFinite(x) && x >= 0 && !(0, _objectIs["default"])(x, -0);
+    }
+    function nonNegativeNumber2(props, propName, componentName) {
+      var value = props[propName];
+      if (value == null || isNonNegative(value)) {
+        return null;
+      }
+      return new RangeError("".concat(propName, " in ").concat(componentName, " must be a non-negative number"));
+    }
+    function requiredNonNegativeNumber(props, propName, componentName) {
+      var value = props[propName];
+      if (isNonNegative(value)) {
+        return null;
+      }
+      return new RangeError("".concat(propName, " in ").concat(componentName, " must be a non-negative number"));
+    }
+    nonNegativeNumber2.isRequired = requiredNonNegativeNumber;
+    var _default = function _default2() {
+      return (0, _wrapValidator["default"])(nonNegativeNumber2, "nonNegativeNumber");
+    };
+    exports["default"] = _default;
+  })(nonNegativeNumber);
+  return nonNegativeNumber;
+}
+export {
+  requireNonNegativeNumber as __require
+};

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

@@ -0,0 +1,55 @@
+import { __exports as numericString } from "../../../../../_virtual/numericString.js";
+import { p as propTypesExports } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredNumericString;
+function requireNumericString() {
+  if (hasRequiredNumericString) return numericString;
+  hasRequiredNumericString = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _propTypes = propTypesExports;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var validNumericChars = /^[-+]?(?:[1-9][0-9]*(?:\.[0-9]+)?|0|0\.[0-9]+)$/;
+    var validator = function numericString2(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];
+      }
+      var stringError = _propTypes.string.apply(void 0, [props, propName, componentName].concat(rest));
+      if (stringError) {
+        return stringError;
+      }
+      var value = props[propName];
+      var passesRegex = validNumericChars.test(value);
+      if (passesRegex) {
+        return null;
+      }
+      return new TypeError("".concat(componentName, ': prop "').concat(propName, '" (value "').concat(value, '") must be a numeric string:\n    - starting with an optional + or -\n    - that does not have a leading zero\n    - with an optional decimal part (that contains only one decimal point, if present)\n    - that otherwise only contains digits (0-9)\n    - not +-NaN, or +-Infinity\n  '));
+    };
+    validator.isRequired = function numericStringRequired(props, propName, componentName) {
+      if (props[propName] == 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));
+    };
+    var _default = function _default2() {
+      return (0, _wrapValidator["default"])(validator, "numericString");
+    };
+    exports["default"] = _default;
+  })(numericString);
+  return numericString;
+}
+export {
+  requireNumericString as __require
+};

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

@@ -0,0 +1,56 @@
+import { __exports as object } from "../../../../../_virtual/object.js";
+import { __require as requireIsPlainObject } from "./helpers/isPlainObject.js";
+import { __require as requireTypeOf } from "./helpers/typeOf.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredObject;
+function requireObject() {
+  if (hasRequiredObject) return object;
+  hasRequiredObject = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _isPlainObject = _interopRequireDefault(requireIsPlainObject());
+    var _typeOf = _interopRequireDefault(requireTypeOf());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var ReactPropTypeLocationNames = {
+      prop: "prop",
+      context: "context",
+      childContext: "child context"
+    };
+    function object2(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      if (propValue == null) {
+        return null;
+      }
+      if ((0, _isPlainObject["default"])(propValue)) {
+        return null;
+      }
+      var locationName = ReactPropTypeLocationNames[location] || location;
+      return new TypeError("Invalid ".concat(locationName, " `").concat(propFullName, "` of type `").concat((0, _typeOf["default"])(propValue), "` supplied to `").concat(componentName, "`, expected `object`."));
+    }
+    object2.isRequired = function objectRequired(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      if (propValue == null) {
+        var locationName = ReactPropTypeLocationNames[location] || location;
+        return new TypeError("The ".concat(locationName, " `").concat(propFullName, "` is marked as required in `").concat(componentName, "`, but its value is `").concat(propValue, "`."));
+      }
+      for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
+        rest[_key - 5] = arguments[_key];
+      }
+      return object2.apply(void 0, [props, propName, componentName, location, propFullName].concat(rest));
+    };
+    var _default = function _default2() {
+      return (0, _wrapValidator["default"])(object2, "object");
+    };
+    exports["default"] = _default;
+  })(object);
+  return object;
+}
+export {
+  requireObject as __require
+};

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

@@ -0,0 +1,96 @@
+import { __exports as or } from "../../../../../_virtual/or.js";
+import { p as propTypesExports } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredOr;
+function requireOr() {
+  if (hasRequiredOr) return or;
+  hasRequiredOr = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = or2;
+    var _propTypes = propTypesExports;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _toConsumableArray(arr) {
+      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+    }
+    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 _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 _iterableToArray(iter) {
+      if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+    }
+    function _arrayWithoutHoles(arr) {
+      if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+    }
+    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 oneOfTypeValidator(validators) {
+      var validator = function oneOfType(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 propValue = props[propName];
+        if (typeof propValue === "undefined") {
+          return null;
+        }
+        var errors = validators.map(function(v) {
+          return v.apply(void 0, [props, propName, componentName].concat(rest));
+        }).filter(Boolean);
+        if (errors.length < validators.length) {
+          return null;
+        }
+        return new TypeError("".concat(componentName, ": invalid value supplied to ").concat(propName, "."));
+      };
+      validator.isRequired = function oneOfTypeRequired(props, propName, componentName) {
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        var propValue = props[propName];
+        if (typeof propValue === "undefined") {
+          return new TypeError("".concat(componentName, ": missing value for required ").concat(propName, "."));
+        }
+        var errors = validators.map(function(v) {
+          return v.apply(void 0, [props, propName, componentName].concat(rest));
+        }).filter(Boolean);
+        if (errors.length === validators.length) {
+          return new TypeError("".concat(componentName, ": invalid value ").concat(errors, " supplied to required ").concat(propName, "."));
+        }
+        return null;
+      };
+      return (0, _wrapValidator["default"])(validator, "oneOfType", validators);
+    }
+    function or2(validators) {
+      var name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "or";
+      if (!Array.isArray(validators)) {
+        throw new TypeError("or: 2 or more validators are required");
+      }
+      if (validators.length <= 1) {
+        throw new RangeError("or: 2 or more validators are required");
+      }
+      var validator = oneOfTypeValidator([(0, _propTypes.arrayOf)(oneOfTypeValidator(validators))].concat(_toConsumableArray(validators)));
+      return (0, _wrapValidator["default"])(validator, name, validators);
+    }
+  })(or);
+  return or;
+}
+export {
+  requireOr as __require
+};

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

@@ -0,0 +1,48 @@
+import { __exports as predicate } from "../../../../../_virtual/predicate.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredPredicate;
+function requirePredicate() {
+  if (hasRequiredPredicate) return predicate;
+  hasRequiredPredicate = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = predicate2;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function predicate2(fn) {
+      var message = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+      if (typeof fn !== "function") {
+        throw new TypeError("`fn` must be a function");
+      }
+      if (typeof message !== "string") {
+        throw new TypeError("`message`, if provided, must be a string");
+      }
+      function requiredValidator(props, propName, componentName) {
+        var result = fn(props[propName]);
+        if (result) {
+          return null;
+        }
+        return new TypeError("`".concat(componentName, "` requires that `").concat(propName, "` pass a predicate function").concat(message ? ": ".concat(message) : "", "."));
+      }
+      function validator(props, propName) {
+        if (props[propName] == null) {
+          return null;
+        }
+        for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+          rest[_key - 2] = arguments[_key];
+        }
+        return requiredValidator.apply(void 0, [props, propName].concat(rest));
+      }
+      validator.isRequired = requiredValidator;
+      return (0, _wrapValidator["default"])(validator, "predicate", fn);
+    }
+  })(predicate);
+  return predicate;
+}
+export {
+  requirePredicate as __require
+};

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

@@ -0,0 +1,49 @@
+import { __exports as range } from "../../../../../_virtual/range.js";
+import { __require as requireAnd } from "./and.js";
+import { __require as requireBetween } from "./between.js";
+import { __require as requireInteger } from "./integer.js";
+import { __require as requireIsInteger } from "./helpers/isInteger.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range;
+  hasRequiredRange = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = range2;
+    var _and = _interopRequireDefault(requireAnd());
+    var _between = _interopRequireDefault(requireBetween());
+    var _integer = _interopRequireDefault(requireInteger());
+    var _isInteger = _interopRequireDefault(requireIsInteger());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    Math.pow(2, 53) - 1;
+    function isValidLength(x) {
+      return (0, _isInteger["default"])(x) && Math.abs(x) < MAX_SAFE_INTEGER;
+    }
+    function range2(min, max) {
+      if (!isValidLength(min) || !isValidLength(max)) {
+        throw new RangeError('"range" requires two integers: '.concat(min, " and ").concat(max, " given"));
+      }
+      if (min === max) {
+        throw new RangeError("min and max must not be the same");
+      }
+      return (0, _wrapValidator["default"])((0, _and["default"])([(0, _integer["default"])(), (0, _between["default"])({
+        gte: min,
+        lt: max
+      })], "range"), "range", {
+        min,
+        max
+      });
+    }
+  })(range);
+  return range;
+}
+export {
+  requireRange as __require
+};

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

@@ -0,0 +1,58 @@
+import { __exports as ref } from "../../../../../_virtual/ref2.js";
+import React__default from "react";
+import { __require as requireIsPlainObject } from "./helpers/isPlainObject.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredRef;
+function requireRef() {
+  if (hasRequiredRef) return ref;
+  hasRequiredRef = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _react = React__default;
+    var _isPlainObject = _interopRequireDefault(requireIsPlainObject());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    var isPrototypeOf = Object.prototype.isPrototypeOf;
+    function isNewRef(prop) {
+      if (!(0, _isPlainObject["default"])(prop)) {
+        return false;
+      }
+      var ownProperties = Object.keys(prop);
+      return ownProperties.length === 1 && ownProperties[0] === "current";
+    }
+    function isCallbackRef(prop) {
+      return typeof prop === "function" && !isPrototypeOf.call(_react.Component, prop) && (!_react.PureComponent || !isPrototypeOf.call(_react.PureComponent, prop));
+    }
+    function requiredRef(props, propName, componentName) {
+      var propValue = props[propName];
+      if (isCallbackRef(propValue) || isNewRef(propValue)) {
+        return null;
+      }
+      return new TypeError("".concat(propName, " in ").concat(componentName, " must be a ref"));
+    }
+    function ref2(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];
+      }
+      return requiredRef.apply(void 0, [props, propName, componentName].concat(rest));
+    }
+    ref2.isRequired = requiredRef;
+    var _default = function _default2() {
+      return (0, _wrapValidator["default"])(ref2, "ref");
+    };
+    exports["default"] = _default;
+  })(ref);
+  return ref;
+}
+export {
+  requireRef as __require
+};

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

@@ -0,0 +1,49 @@
+import { __exports as requiredBy } from "../../../../../_virtual/requiredBy.js";
+import { __require as requireObjectIs } from "../../../../object-is/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredRequiredBy;
+function requireRequiredBy() {
+  if (hasRequiredRequiredBy) return requiredBy;
+  hasRequiredRequiredBy = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = getRequiredBy;
+    var _objectIs = _interopRequireDefault(requireObjectIs());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function getRequiredBy(requiredByPropName, propType) {
+      var defaultValue = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+      function requiredBy2(props, propName, componentName) {
+        if (props[requiredByPropName]) {
+          var propValue = props[propName];
+          if ((0, _objectIs["default"])(propValue, defaultValue) || typeof propValue === "undefined") {
+            return new TypeError("".concat(componentName, ": when ").concat(requiredByPropName, " is true, prop “").concat(propName, "” must be present."));
+          }
+        }
+        for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+          rest[_key - 3] = arguments[_key];
+        }
+        return propType.apply(void 0, [props, propName, componentName].concat(rest));
+      }
+      requiredBy2.isRequired = function requiredByRequired(props, propName, componentName) {
+        var propValue = props[propName];
+        if ((0, _objectIs["default"])(propValue, defaultValue)) {
+          return new TypeError("".concat(componentName, ": prop “").concat(propName, "” must be present."));
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return propType.isRequired.apply(propType, [props, propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(requiredBy2, "requiredBy “".concat(requiredByPropName, "”"), [requiredByPropName, defaultValue]);
+    }
+  })(requiredBy);
+  return requiredBy;
+}
+export {
+  requireRequiredBy as __require
+};

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

@@ -0,0 +1,42 @@
+import { __exports as restrictedProp } from "../../../../../_virtual/restrictedProp.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredRestrictedProp;
+function requireRestrictedProp() {
+  if (hasRequiredRestrictedProp) return restrictedProp;
+  hasRequiredRestrictedProp = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function customMessageWrapper(messsageFunction) {
+      function restrictedProp2(props, propName, componentName, location) {
+        if (props[propName] == null) {
+          return null;
+        }
+        if (messsageFunction && typeof messsageFunction === "function") {
+          for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
+            rest[_key - 4] = arguments[_key];
+          }
+          return new TypeError(messsageFunction.apply(void 0, [props, propName, componentName, location].concat(rest)));
+        }
+        return new TypeError("The ".concat(propName, " ").concat(location, " on ").concat(componentName, " is not allowed."));
+      }
+      restrictedProp2.isRequired = restrictedProp2;
+      return restrictedProp2;
+    }
+    var _default = function _default2() {
+      var messsageFunction = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+      return (0, _wrapValidator["default"])(customMessageWrapper(messsageFunction), "restrictedProp");
+    };
+    exports["default"] = _default;
+  })(restrictedProp);
+  return restrictedProp;
+}
+export {
+  requireRestrictedProp as __require
+};