impact-ui 5.0.0-alpha.2 → 5.0.0-alpha.3

package/dist/node_modules/react-dates/lib/shapes/ModifiersShape.js

@@ -0,0 +1,41 @@
+import { __exports as ModifiersShape } from "../../../../_virtual/ModifiersShape.js";
+import require$$0 from "@babel/runtime/helpers/interopRequireDefault";
+import require$$1 from "@babel/runtime/helpers/defineProperty";
+import require$$2 from "@babel/runtime/helpers/toConsumableArray";
+import { __require as requirePropTypes } from "../../../prop-types/index.js";
+import { __require as requireAirbnbPropTypes } from "../../node_modules/airbnb-prop-types/index.js";
+var hasRequiredModifiersShape;
+function requireModifiersShape() {
+  if (hasRequiredModifiersShape) return ModifiersShape;
+  hasRequiredModifiersShape = 1;
+  (function(exports) {
+    var _interopRequireDefault = require$$0;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = void 0;
+    var _defineProperty2 = _interopRequireDefault(require$$1);
+    var _toConsumableArray2 = _interopRequireDefault(require$$2);
+    var _propTypes = _interopRequireDefault(requirePropTypes());
+    var _airbnbPropTypes = requireAirbnbPropTypes();
+    var _default = (0, _airbnbPropTypes.and)([_propTypes["default"].instanceOf(Set), function modifiers(props, propName) {
+      for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        rest[_key - 2] = arguments[_key];
+      }
+      var propValue = props[propName];
+      var firstError;
+      (0, _toConsumableArray2["default"])(propValue).some(function(v, i) {
+        var _PropTypes$string;
+        var fakePropName = "".concat(propName, ": index ").concat(i);
+        firstError = (_PropTypes$string = _propTypes["default"].string).isRequired.apply(_PropTypes$string, [(0, _defineProperty2["default"])({}, fakePropName, v), fakePropName].concat(rest));
+        return firstError != null;
+      });
+      return firstError == null ? null : firstError;
+    }], "Modifiers (Set of Strings)");
+    exports["default"] = _default;
+  })(ModifiersShape);
+  return ModifiersShape;
+}
+export {
+  requireModifiersShape as __require
+};

package/dist/node_modules/react-dates/lib/utils/getCalendarDaySettings.js

@@ -0,0 +1,64 @@
+import { __exports as getCalendarDaySettings } from "../../../../_virtual/getCalendarDaySettings.js";
+import require$$0 from "@babel/runtime/helpers/interopRequireDefault";
+import { __require as requireGetPhrase } from "./getPhrase.js";
+import { __require as requireConstants } from "../constants.js";
+var hasRequiredGetCalendarDaySettings;
+function requireGetCalendarDaySettings() {
+  if (hasRequiredGetCalendarDaySettings) return getCalendarDaySettings;
+  hasRequiredGetCalendarDaySettings = 1;
+  (function(exports) {
+    var _interopRequireDefault = require$$0;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = getCalendarDaySettings2;
+    var _getPhrase = _interopRequireDefault(requireGetPhrase());
+    var _constants = requireConstants();
+    function isSelected(modifiers) {
+      return modifiers.has("selected") || modifiers.has("selected-span") || modifiers.has("selected-start") || modifiers.has("selected-end");
+    }
+    function shouldUseDefaultCursor(modifiers) {
+      return modifiers.has("blocked-minimum-nights") || modifiers.has("blocked-calendar") || modifiers.has("blocked-out-of-range");
+    }
+    function isHoveredSpan(modifiers) {
+      if (isSelected(modifiers)) return false;
+      return modifiers.has("hovered-span") || modifiers.has("after-hovered-start") || modifiers.has("before-hovered-end");
+    }
+    function getAriaLabel(phrases, modifiers, day, ariaLabelFormat) {
+      var chooseAvailableDate = phrases.chooseAvailableDate, dateIsUnavailable = phrases.dateIsUnavailable, dateIsSelected = phrases.dateIsSelected, dateIsSelectedAsStartDate = phrases.dateIsSelectedAsStartDate, dateIsSelectedAsEndDate = phrases.dateIsSelectedAsEndDate;
+      var formattedDate = {
+        date: day.format(ariaLabelFormat)
+      };
+      if (modifiers.has("selected-start") && dateIsSelectedAsStartDate) {
+        return (0, _getPhrase["default"])(dateIsSelectedAsStartDate, formattedDate);
+      }
+      if (modifiers.has("selected-end") && dateIsSelectedAsEndDate) {
+        return (0, _getPhrase["default"])(dateIsSelectedAsEndDate, formattedDate);
+      }
+      if (isSelected(modifiers) && dateIsSelected) {
+        return (0, _getPhrase["default"])(dateIsSelected, formattedDate);
+      }
+      if (modifiers.has(_constants.BLOCKED_MODIFIER)) {
+        return (0, _getPhrase["default"])(dateIsUnavailable, formattedDate);
+      }
+      return (0, _getPhrase["default"])(chooseAvailableDate, formattedDate);
+    }
+    function getCalendarDaySettings2(day, ariaLabelFormat, daySize, modifiers, phrases) {
+      return {
+        ariaLabel: getAriaLabel(phrases, modifiers, day, ariaLabelFormat),
+        hoveredSpan: isHoveredSpan(modifiers),
+        isOutsideRange: modifiers.has("blocked-out-of-range"),
+        selected: isSelected(modifiers),
+        useDefaultCursor: shouldUseDefaultCursor(modifiers),
+        daySizeStyles: {
+          width: daySize,
+          height: daySize - 1
+        }
+      };
+    }
+  })(getCalendarDaySettings);
+  return getCalendarDaySettings;
+}
+export {
+  requireGetCalendarDaySettings as __require
+};

package/dist/node_modules/react-dates/lib/utils/getPhrase.js

@@ -0,0 +1,23 @@
+import { __exports as getPhrase } from "../../../../_virtual/getPhrase.js";
+var hasRequiredGetPhrase;
+function requireGetPhrase() {
+  if (hasRequiredGetPhrase) return getPhrase;
+  hasRequiredGetPhrase = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = getPhrase2;
+    function getPhrase2(phrase, args) {
+      if (typeof phrase === "string") return phrase;
+      if (typeof phrase === "function") {
+        return phrase(args);
+      }
+      return "";
+    }
+  })(getPhrase);
+  return getPhrase;
+}
+export {
+  requireGetPhrase as __require
+};

package/dist/node_modules/react-dates/lib/utils/getPhrasePropTypes.js

@@ -0,0 +1,55 @@
+import { __exports as getPhrasePropTypes } from "../../../../_virtual/getPhrasePropTypes.js";
+import require$$0 from "@babel/runtime/helpers/interopRequireDefault";
+import require$$1 from "@babel/runtime/helpers/defineProperty";
+import { __require as requirePropTypes } from "../../../prop-types/index.js";
+var hasRequiredGetPhrasePropTypes;
+function requireGetPhrasePropTypes() {
+  if (hasRequiredGetPhrasePropTypes) return getPhrasePropTypes;
+  hasRequiredGetPhrasePropTypes = 1;
+  (function(exports) {
+    var _interopRequireDefault = require$$0;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = getPhrasePropTypes2;
+    var _defineProperty2 = _interopRequireDefault(require$$1);
+    var _propTypes = _interopRequireDefault(requirePropTypes());
+    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) {
+            (0, _defineProperty2["default"])(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 getPhrasePropTypes2(defaultPhrases) {
+      return Object.keys(defaultPhrases).reduce(function(phrases, key) {
+        return _objectSpread({}, phrases, (0, _defineProperty2["default"])({}, key, _propTypes["default"].oneOfType([_propTypes["default"].string, _propTypes["default"].func, _propTypes["default"].node])));
+      }, {});
+    }
+  })(getPhrasePropTypes);
+  return getPhrasePropTypes;
+}
+export {
+  requireGetPhrasePropTypes as __require
+};

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

@@ -0,0 +1,53 @@
+import { __exports as and } from "../../../../../_virtual/and.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredAnd;
+function requireAnd() {
+  if (hasRequiredAnd) return and;
+  hasRequiredAnd = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = andValidator;
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function andValidator(validators) {
+      var name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "and";
+      if (!Array.isArray(validators)) {
+        throw new TypeError("and: 2 or more validators are required");
+      }
+      if (validators.length <= 1) {
+        throw new RangeError("and: 2 or more validators are required");
+      }
+      var validator = function and2() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        var firstError = null;
+        validators.some(function(validatorFn) {
+          firstError = validatorFn.apply(void 0, args);
+          return firstError != null;
+        });
+        return firstError == null ? null : firstError;
+      };
+      validator.isRequired = function andIsRequired() {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        var firstError = null;
+        validators.some(function(validatorFn) {
+          firstError = validatorFn.isRequired.apply(validatorFn, args);
+          return firstError != null;
+        });
+        return firstError == null ? null : firstError;
+      };
+      return (0, _wrapValidator["default"])(validator, name, validators);
+    }
+  })(and);
+  return and;
+}
+export {
+  requireAnd as __require
+};

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

@@ -0,0 +1,276 @@
+import { __exports as between } from "../../../../../_virtual/between.js";
+import { __require as requireObject_entries } from "../../../../object.entries/index.js";
+import { __require as requireShape } from "./shape.js";
+import { __require as requireValuesOf } from "./valuesOf.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredBetween;
+function requireBetween() {
+  if (hasRequiredBetween) return between;
+  hasRequiredBetween = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = betweenValidator;
+    var _object = _interopRequireDefault(requireObject_entries());
+    var _shape = _interopRequireDefault(requireShape());
+    var _valuesOf = _interopRequireDefault(requireValuesOf());
+    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 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 _slicedToArray(arr, i) {
+      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+    }
+    function _nonIterableRest() {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    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 _iterableToArrayLimit(arr, i) {
+      if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+      var _arr = [];
+      var _n = true;
+      var _d = false;
+      var _e = void 0;
+      try {
+        for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+          _arr.push(_s.value);
+          if (i && _arr.length === i) break;
+        }
+      } catch (err) {
+        _d = true;
+        _e = err;
+      } finally {
+        try {
+          if (!_n && _i["return"] != null) _i["return"]();
+        } finally {
+          if (_d) throw _e;
+        }
+      }
+      return _arr;
+    }
+    function _arrayWithHoles(arr) {
+      if (Array.isArray(arr)) return arr;
+    }
+    function number(props, propName, componentName) {
+      var value = props[propName];
+      if (typeof value === "number" && !isNaN(value)) {
+        return null;
+      }
+      return new TypeError("".concat(componentName, ": ").concat(propName, " must be a non-NaN number."));
+    }
+    function numberOrPropsFunc(props, propName) {
+      var value = props[propName];
+      if (typeof value === "function") {
+        return null;
+      }
+      if (typeof value === "number" && !isNaN(value)) {
+        return null;
+      }
+      return new TypeError("".concat(propName, ": a function, or a non-NaN number is required"));
+    }
+    function lowerCompare(value, _ref) {
+      var gt = _ref.gt, gte = _ref.gte;
+      if (typeof gt === "number") {
+        return value > gt;
+      }
+      if (typeof gte === "number") {
+        return value >= gte;
+      }
+      return true;
+    }
+    function upperCompare(value, _ref2) {
+      var lt = _ref2.lt, lte = _ref2.lte;
+      if (typeof lt === "number") {
+        return value < lt;
+      }
+      if (typeof lte === "number") {
+        return value <= lte;
+      }
+      return true;
+    }
+    function greaterThanError(_ref3) {
+      var gt = _ref3.gt, gte = _ref3.gte;
+      if (typeof gt === "number") {
+        return "greater than ".concat(gt);
+      }
+      if (typeof gte === "number") {
+        return "greater than or equal to ".concat(gte);
+      }
+      return "";
+    }
+    function lessThanError(_ref4) {
+      var lt = _ref4.lt, lte = _ref4.lte;
+      if (typeof lt === "number") {
+        return "less than ".concat(lt);
+      }
+      if (typeof lte === "number") {
+        return "less than or equal to ".concat(lte);
+      }
+      return "";
+    }
+    function errorMessage(componentName, propName, opts) {
+      var errors = [greaterThanError(opts), lessThanError(opts)].filter(Boolean).join(" and ");
+      return "".concat(componentName, ": ").concat(propName, " must be ").concat(errors);
+    }
+    function propsThunkify(opts) {
+      return (0, _object["default"])(opts).reduce(function(acc, _ref5) {
+        var _ref6 = _slicedToArray(_ref5, 2), key = _ref6[0], value = _ref6[1];
+        var numberThunk = typeof value === "number" ? function() {
+          return value;
+        } : value;
+        return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, key, numberThunk));
+      }, {});
+    }
+    function invokeWithProps(optsThunks, props) {
+      return (0, _object["default"])(optsThunks).reduce(function(acc, _ref7) {
+        var _ref8 = _slicedToArray(_ref7, 2), key = _ref8[0], thunk = _ref8[1];
+        var value = thunk(props);
+        return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, key, value));
+      }, {});
+    }
+    var argValidators = [(0, _shape["default"])({
+      lt: numberOrPropsFunc,
+      gt: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      lte: numberOrPropsFunc,
+      gt: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      lt: numberOrPropsFunc,
+      gte: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      lte: numberOrPropsFunc,
+      gte: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      lt: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      lte: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      gt: numberOrPropsFunc
+    }).isRequired, (0, _shape["default"])({
+      gte: numberOrPropsFunc
+    }).isRequired];
+    function argValidator(props, propName) {
+      return argValidators.every(function(validator) {
+        return !!validator(props, propName);
+      });
+    }
+    var thunkValueValidator = (0, _valuesOf["default"])(number).isRequired;
+    function betweenValidator(options) {
+      var argError = argValidator({
+        options
+      }, "options");
+      if (argError) {
+        throw new TypeError("between: only one of the pairs of `lt`/`lte`, and `gt`/`gte`, may be supplied, and at least one pair must be provided.");
+      }
+      var optsThunks = propsThunkify(options);
+      var validator = function between2(props, propName, componentName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        if (typeof propValue !== "number") {
+          return new RangeError("".concat(componentName, ": ").concat(propName, ' must be a number, got "').concat(_typeof(propValue), '"'));
+        }
+        var opts = invokeWithProps(optsThunks, 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 thunkValuesError = thunkValueValidator.apply(void 0, [_defineProperty({}, propName, opts), propName, componentName].concat(rest));
+        if (thunkValuesError) {
+          return thunkValuesError;
+        }
+        if (!lowerCompare(propValue, opts) || !upperCompare(propValue, opts)) {
+          return new RangeError(errorMessage(componentName, propName, opts));
+        }
+        return null;
+      };
+      validator.isRequired = function betweenRequired(props, propName, componentName) {
+        var propValue = props[propName];
+        if (typeof propValue !== "number") {
+          return new RangeError("".concat(componentName, ": ").concat(propName, ' must be a number, got "').concat(_typeof(propValue), '"'));
+        }
+        var opts = invokeWithProps(optsThunks, props);
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        var thunkValuesError = thunkValueValidator.apply(void 0, [_defineProperty({}, propName, opts), propName, componentName].concat(rest));
+        if (thunkValuesError) {
+          return thunkValuesError;
+        }
+        if (!lowerCompare(propValue, opts) || !upperCompare(propValue, opts)) {
+          return new RangeError(errorMessage(componentName, propName, opts));
+        }
+        return null;
+      };
+      return (0, _wrapValidator["default"])(validator, "between", options);
+    }
+  })(between);
+  return between;
+}
+export {
+  requireBetween as __require
+};

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

@@ -0,0 +1,64 @@
+import { __exports as booleanSome } from "../../../../../_virtual/booleanSome.js";
+import { __require as requirePropTypes } from "../../../../prop-types/index.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredBooleanSome;
+function requireBooleanSome() {
+  if (hasRequiredBooleanSome) return booleanSome;
+  hasRequiredBooleanSome = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = booleanSomeValidator;
+    var _propTypes = requirePropTypes();
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function booleanSomeValidator() {
+      for (var _len = arguments.length, notAllPropsFalse = new Array(_len), _key = 0; _key < _len; _key++) {
+        notAllPropsFalse[_key] = arguments[_key];
+      }
+      if (notAllPropsFalse.length < 1) {
+        throw new TypeError("at least one prop (one of which must be `true`) is required");
+      }
+      if (!notAllPropsFalse.every(function(x) {
+        return typeof x === "string";
+      })) {
+        throw new TypeError("all booleanSome props must be strings");
+      }
+      var propsList = notAllPropsFalse.join(", or ");
+      var validator = function booleanSome2(props, propName, componentName) {
+        var countFalse = function countFalse2(count, prop) {
+          return count + (props[prop] === false ? 1 : 0);
+        };
+        var falsePropCount = notAllPropsFalse.reduce(countFalse, 0);
+        if (falsePropCount === notAllPropsFalse.length) {
+          return new Error("A ".concat(componentName, " must have at least 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 booleanSomeRequired(props, propName, componentName) {
+        var countFalse = function countFalse2(count, prop) {
+          return count + (props[prop] === false ? 1 : 0);
+        };
+        var falsePropCount = notAllPropsFalse.reduce(countFalse, 0);
+        if (falsePropCount === notAllPropsFalse.length) {
+          return new Error("A ".concat(componentName, " must have at least 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, "booleanSome: ".concat(propsList), notAllPropsFalse);
+    }
+  })(booleanSome);
+  return booleanSome;
+}
+export {
+  requireBooleanSome as __require
+};

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
+};