impact-ui 4.0.17 → 4.0.18-alpha.1

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 { __require as requirePropTypes } 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 = requirePropTypes();
+    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
+};

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