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

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

@@ -0,0 +1,211 @@
+import { __exports as sequenceOf } from "../../../../../_virtual/sequenceOf.js";
+import { __require as requirePropTypes } from "../../../../prop-types/index.js";
+import { __require as requireAnd } from "./and.js";
+import { __require as requireBetween } from "./between.js";
+import { __require as requireNonNegativeInteger } from "./nonNegativeInteger.js";
+import { __require as requireObject } from "./object.js";
+import { __require as requireWithShape } from "./withShape.js";
+import { __require as requireTypeOf } from "./helpers/typeOf.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredSequenceOf;
+function requireSequenceOf() {
+  if (hasRequiredSequenceOf) return sequenceOf;
+  hasRequiredSequenceOf = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = sequenceOfValidator;
+    var _propTypes = requirePropTypes();
+    var _and = _interopRequireDefault(requireAnd());
+    var _between = _interopRequireDefault(requireBetween());
+    var _nonNegativeInteger = _interopRequireDefault(requireNonNegativeInteger());
+    var _object = _interopRequireDefault(requireObject());
+    var _withShape = _interopRequireDefault(requireWithShape());
+    var _typeOf = _interopRequireDefault(requireTypeOf());
+    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;
+    }
+    var minValidator = _nonNegativeInteger["default"];
+    var maxValidator = (0, _and["default"])([_nonNegativeInteger["default"], (0, _between["default"])({
+      gte: 1
+    })]);
+    function validateRange(min, max) {
+      if (typeof max !== "number" || typeof min !== "number") {
+        return null;
+      }
+      if (min <= max) {
+        return null;
+      }
+      return new RangeError("min must be less than or equal to max");
+    }
+    var specifierShape = {
+      validator: function validator(props, propName) {
+        var propValue = props[propName];
+        if (typeof propValue !== "function") {
+          return new TypeError('"validator" must be a propType validator function');
+        }
+        return null;
+      },
+      min: function min(props, propName) {
+        return minValidator(props, propName) || validateRange(props.min, props.max);
+      },
+      max: function max(props, propName) {
+        return maxValidator(props, propName) || validateRange(props.min, props.max);
+      }
+    };
+    function getMinMax(_ref) {
+      var min = _ref.min, max = _ref.max;
+      var minimum;
+      var maximum;
+      if (typeof min !== "number" && typeof max !== "number") {
+        minimum = 1;
+        maximum = 1;
+      } else {
+        minimum = typeof min === "number" ? min : 1;
+        maximum = typeof max === "number" ? max : Infinity;
+      }
+      return {
+        minimum,
+        maximum
+      };
+    }
+    function chunkByType(items) {
+      var chunk = [];
+      var lastType;
+      return items.reduce(function(chunks, item) {
+        var itemType = (0, _typeOf["default"])(item);
+        if (!lastType || itemType === lastType) {
+          chunk.push(item);
+        } else {
+          chunks.push(chunk);
+          chunk = [item];
+        }
+        lastType = itemType;
+        return chunks;
+      }, []).concat(chunk.length > 0 ? [chunk] : []);
+    }
+    function validateChunks(specifiers, props, propName, componentName) {
+      var items = props[propName];
+      var chunks = chunkByType(items);
+      for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
+        rest[_key - 4] = arguments[_key];
+      }
+      for (var i = 0; i < specifiers.length; i += 1) {
+        var _specifiers$i = specifiers[i], validator = _specifiers$i.validator, min = _specifiers$i.min, max = _specifiers$i.max;
+        var _getMinMax = getMinMax({
+          min,
+          max
+        }), minimum = _getMinMax.minimum, maximum = _getMinMax.maximum;
+        if (chunks.length === 0 && minimum === 0) {
+          continue;
+        }
+        var arrayOfValidator = (0, _propTypes.arrayOf)(validator).isRequired;
+        var chunk = chunks.shift();
+        var chunkError = arrayOfValidator.apply(void 0, [_objectSpread(_objectSpread({}, props), {}, _defineProperty({}, propName, chunk)), propName, componentName].concat(rest));
+        if (chunkError) {
+          if (minimum === 0) {
+            chunks.unshift(chunk);
+            continue;
+          }
+          return chunkError;
+        }
+        if (chunk.length < minimum) {
+          return new RangeError("".concat(componentName, ": specifier index ").concat(i, " requires a minimum of ").concat(min, " items, but only has ").concat(chunk.length, "."));
+        }
+        if (chunk.length > maximum) {
+          return new RangeError("".concat(componentName, ": specifier index ").concat(i, " requires a maximum of ").concat(max, " items, but has ").concat(chunk.length, "."));
+        }
+      }
+      if (chunks.length > 0) {
+        return new TypeError("".concat(componentName, ": after all ").concat(specifiers.length, " specifiers matched, ").concat(chunks.length, " types of items were remaining."));
+      }
+      return null;
+    }
+    var specifierValidator = (0, _withShape["default"])((0, _object["default"])(), specifierShape).isRequired;
+    function sequenceOfValidator() {
+      for (var _len2 = arguments.length, specifiers = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        specifiers[_key2] = arguments[_key2];
+      }
+      if (specifiers.length === 0) {
+        throw new RangeError("sequenceOf: at least one specifier is required");
+      }
+      var errors = specifiers.map(function(specifier, i) {
+        return specifierValidator({
+          specifier
+        }, "specifier", "sequenceOf specifier", "suequenceOf specifier, index ".concat(i), "specifier, index ".concat(i));
+      });
+      if (errors.some(Boolean)) {
+        throw new TypeError("\n      sequenceOf: all specifiers must match the appropriate shape.\n\n      Errors:\n        ".concat(errors.map(function(e, i) {
+          return " - Argument index ".concat(i, ": ").concat(e.message);
+        }).join(",\n        "), "\n    "));
+      }
+      var validator = function sequenceOf2(props, propName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        for (var _len3 = arguments.length, rest = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+          rest[_key3 - 2] = arguments[_key3];
+        }
+        var error = _propTypes.array.apply(void 0, [props, propName].concat(rest));
+        if (error) {
+          return error;
+        }
+        return validateChunks.apply(void 0, [specifiers, props, propName].concat(rest));
+      };
+      validator.isRequired = function sequenceOfRequired(props, propName, componentName) {
+        for (var _len4 = arguments.length, rest = new Array(_len4 > 3 ? _len4 - 3 : 0), _key4 = 3; _key4 < _len4; _key4++) {
+          rest[_key4 - 3] = arguments[_key4];
+        }
+        var error = _propTypes.array.isRequired.apply(_propTypes.array, [props, propName, componentName].concat(rest));
+        if (error) {
+          return error;
+        }
+        return validateChunks.apply(void 0, [specifiers, props, propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(validator, "sequenceOf", specifiers);
+    }
+  })(sequenceOf);
+  return sequenceOf;
+}
+export {
+  requireSequenceOf as __require
+};

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

@@ -0,0 +1,58 @@
+import { __exports as shape } from "../../../../../_virtual/shape.js";
+import { __require as requireIsPlainObject } from "./helpers/isPlainObject.js";
+import { __require as requireWrapValidator } from "./helpers/wrapValidator.js";
+var hasRequiredShape;
+function requireShape() {
+  if (hasRequiredShape) return shape;
+  hasRequiredShape = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports["default"] = shapeValidator;
+    var _isPlainObject = _interopRequireDefault(requireIsPlainObject());
+    var _wrapValidator = _interopRequireDefault(requireWrapValidator());
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function shapeValidator(shapeTypes) {
+      if (!(0, _isPlainObject["default"])(shapeTypes)) {
+        throw new TypeError("shape must be a normal object");
+      }
+      function shape2(props, propName, componentName, location) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return null;
+        }
+        for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
+          rest[_key - 4] = arguments[_key];
+        }
+        for (var key in shapeTypes) {
+          var checker = shapeTypes[key];
+          if (checker) {
+            var error = checker.apply(void 0, [propValue, key, componentName, location].concat(rest));
+            if (error) {
+              return error;
+            }
+          }
+        }
+        return null;
+      }
+      shape2.isRequired = function shapeRequired(props, propName, componentName) {
+        var propValue = props[propName];
+        if (propValue == null) {
+          return new TypeError("".concat(componentName, ": ").concat(propName, " is required."));
+        }
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+          rest[_key2 - 3] = arguments[_key2];
+        }
+        return shape2.apply(void 0, [props, propName, componentName].concat(rest));
+      };
+      return (0, _wrapValidator["default"])(shape2, "shape", shapeTypes);
+    }
+  })(shape);
+  return shape;
+}
+export {
+  requireShape as __require
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/node_modules/react-is/index.js

@@ -1,4 +1,4 @@
-import { __module as reactIs } from "../../_virtual/index4.js";
+import { __module as reactIs } from "../../_virtual/index7.js";
 import { __require as requireReactIs_production_min } from "./cjs/react-is.production.min.js";
 import { __require as requireReactIs_development } from "./cjs/react-is.development.js";
 var hasRequiredReactIs;