impact-ui 4.0.17 → 4.0.18-alpha.1

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

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