{"version":3,"file":"npm.prop-types.b1f4cfad.js","mappings":"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","sources":["webpack://goodkind-frontend/./node_modules/prop-types/checkPropTypes.js","webpack://goodkind-frontend/./node_modules/prop-types/factoryWithTypeCheckers.js","webpack://goodkind-frontend/./node_modules/prop-types/index.js","webpack://goodkind-frontend/./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://goodkind-frontend/./node_modules/prop-types/lib/has.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n  var has = require('./lib/has');\n\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) { /**/ }\n  };\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (has(typeSpecs, typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            var err = Error(\n              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\n              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +\n              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'\n            );\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        if (error && !(error instanceof Error)) {\n          printWarning(\n            (componentName || 'React class') + ': type specification of ' +\n            location + ' `' + typeSpecName + '` is invalid; the type checker ' +\n            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\n            'You may have forgotten to pass an argument to the type checker ' +\n            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\n            'shape all require an argument).'\n          );\n        }\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          printWarning(\n            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Resets warning cache when testing.\n *\n * @private\n */\ncheckPropTypes.resetWarningCache = function() {\n  if (process.env.NODE_ENV !== 'production') {\n    loggedTypeFailures = {};\n  }\n}\n\nmodule.exports = checkPropTypes;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactIs = require('react-is');\nvar assign = require('object-assign');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar has = require('./lib/has');\nvar checkPropTypes = require('./checkPropTypes');\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n}\n\nfunction emptyFunctionThatReturnsNull() {\n  return null;\n}\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n  /* global Symbol */\n  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n  /**\n   * Returns the iterator method function contained on the iterable object.\n   *\n   * Be sure to invoke the function with the iterable as context:\n   *\n   *     var iteratorFn = getIteratorFn(myIterable);\n   *     if (iteratorFn) {\n   *       var iterator = iteratorFn.call(myIterable);\n   *       ...\n   *     }\n   *\n   * @param {?object} maybeIterable\n   * @return {?function}\n   */\n  function getIteratorFn(maybeIterable) {\n    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  /**\n   * Collection of methods that allow declaration and validation of props that are\n   * supplied to React components. Example usage:\n   *\n   *   var Props = require('ReactPropTypes');\n   *   var MyArticle = React.createClass({\n   *     propTypes: {\n   *       // An optional string prop named \"description\".\n   *       description: Props.string,\n   *\n   *       // A required enum prop named \"category\".\n   *       category: Props.oneOf(['News','Photos']).isRequired,\n   *\n   *       // A prop named \"dialog\" that requires an instance of Dialog.\n   *       dialog: Props.instanceOf(Dialog).isRequired\n   *     },\n   *     render: function() { ... }\n   *   });\n   *\n   * A more formal specification of how these methods are used:\n   *\n   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n   *   decl := ReactPropTypes.{type}(.isRequired)?\n   *\n   * Each and every declaration produces a function with the same signature. This\n   * allows the creation of custom validation functions. For example:\n   *\n   *  var MyLink = React.createClass({\n   *    propTypes: {\n   *      // An optional string or URI prop named \"href\".\n   *      href: function(props, propName, componentName) {\n   *        var propValue = props[propName];\n   *        if (propValue != null && typeof propValue !== 'string' &&\n   *            !(propValue instanceof URI)) {\n   *          return new Error(\n   *            'Expected a string or an URI for ' + propName + ' in ' +\n   *            componentName\n   *          );\n   *        }\n   *      }\n   *    },\n   *    render: function() {...}\n   *  });\n   *\n   * @internal\n   */\n\n  var ANONYMOUS = '<<anonymous>>';\n\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n  var ReactPropTypes = {\n    array: createPrimitiveTypeChecker('array'),\n    bigint: createPrimitiveTypeChecker('bigint'),\n    bool: createPrimitiveTypeChecker('boolean'),\n    func: createPrimitiveTypeChecker('function'),\n    number: createPrimitiveTypeChecker('number'),\n    object: createPrimitiveTypeChecker('object'),\n    string: createPrimitiveTypeChecker('string'),\n    symbol: createPrimitiveTypeChecker('symbol'),\n\n    any: createAnyTypeChecker(),\n    arrayOf: createArrayOfTypeChecker,\n    element: createElementTypeChecker(),\n    elementType: createElementTypeTypeChecker(),\n    instanceOf: createInstanceTypeChecker,\n    node: createNodeChecker(),\n    objectOf: createObjectOfTypeChecker,\n    oneOf: createEnumTypeChecker,\n    oneOfType: createUnionTypeChecker,\n    shape: createShapeTypeChecker,\n    exact: createStrictShapeTypeChecker,\n  };\n\n  /**\n   * inlined Object.is polyfill to avoid requiring consumers ship their own\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n   */\n  /*eslint-disable no-self-compare*/\n  function is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n      // Steps 1-5, 7-10\n      // Steps 6.b-6.e: +0 != -0\n      return x !== 0 || 1 / x === 1 / y;\n    } else {\n      // Step 6.a: NaN == NaN\n      return x !== x && y !== y;\n    }\n  }\n  /*eslint-enable no-self-compare*/\n\n  /**\n   * We use an Error-like object for backward compatibility as people may call\n   * PropTypes directly and inspect their output. However, we don't use real\n   * Errors anymore. We don't inspect their stack anyway, and creating them\n   * is prohibitively expensive if they are created too often, such as what\n   * happens in oneOfType() for any type before the one that matched.\n   */\n  function PropTypeError(message, data) {\n    this.message = message;\n    this.data = data && typeof data === 'object' ? data: {};\n    this.stack = '';\n  }\n  // Make `instanceof Error` still work for returned errors.\n  PropTypeError.prototype = Error.prototype;\n\n  function createChainableTypeChecker(validate) {\n    if (process.env.NODE_ENV !== 'production') {\n      var manualPropTypeCallCache = {};\n      var manualPropTypeWarningCount = 0;\n    }\n    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n      componentName = componentName || ANONYMOUS;\n      propFullName = propFullName || propName;\n\n      if (secret !== ReactPropTypesSecret) {\n        if (throwOnDirectAccess) {\n          // New behavior only for users of `prop-types` package\n          var err = new Error(\n            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n            'Use `PropTypes.checkPropTypes()` to call them. ' +\n            'Read more at http://fb.me/use-check-prop-types'\n          );\n          err.name = 'Invariant Violation';\n          throw err;\n        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n          // Old behavior for people using React.PropTypes\n          var cacheKey = componentName + ':' + propName;\n          if (\n            !manualPropTypeCallCache[cacheKey] &&\n            // Avoid spamming the console because they are often not actionable except for lib authors\n            manualPropTypeWarningCount < 3\n          ) {\n            printWarning(\n              'You are manually calling a React.PropTypes validation ' +\n              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +\n              'and will throw in the standalone `prop-types` package. ' +\n              'You may be seeing this warning due to a third-party PropTypes ' +\n              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'\n            );\n            manualPropTypeCallCache[cacheKey] = true;\n            manualPropTypeWarningCount++;\n          }\n        }\n      }\n      if (props[propName] == null) {\n        if (isRequired) {\n          if (props[propName] === null) {\n            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n          }\n          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n        }\n        return null;\n      } else {\n        return validate(props, propName, componentName, location, propFullName);\n      }\n    }\n\n    var chainedCheckType = checkType.bind(null, false);\n    chainedCheckType.isRequired = checkType.bind(null, true);\n\n    return chainedCheckType;\n  }\n\n  function createPrimitiveTypeChecker(expectedType) {\n    function validate(props, propName, componentName, location, propFullName, secret) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== expectedType) {\n        // `propValue` being instance of, say, date/regexp, pass the 'object'\n        // check, but we can offer a more precise error message here rather than\n        // 'of type `object`'.\n        var preciseType = getPreciseType(propValue);\n\n        return new PropTypeError(\n          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),\n          {expectedType: expectedType}\n        );\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createAnyTypeChecker() {\n    return createChainableTypeChecker(emptyFunctionThatReturnsNull);\n  }\n\n  function createArrayOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n      }\n      var propValue = props[propName];\n      if (!Array.isArray(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n      }\n      for (var i = 0; i < propValue.length; i++) {\n        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n        if (error instanceof Error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!isValidElement(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!ReactIs.isValidElementType(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createInstanceTypeChecker(expectedClass) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!(props[propName] instanceof expectedClass)) {\n        var expectedClassName = expectedClass.name || ANONYMOUS;\n        var actualClassName = getClassName(props[propName]);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createEnumTypeChecker(expectedValues) {\n    if (!Array.isArray(expectedValues)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (arguments.length > 1) {\n          printWarning(\n            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +\n            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'\n          );\n        } else {\n          printWarning('Invalid argument supplied to oneOf, expected an array.');\n        }\n      }\n      return emptyFunctionThatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      for (var i = 0; i < expectedValues.length; i++) {\n        if (is(propValue, expectedValues[i])) {\n          return null;\n        }\n      }\n\n      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {\n        var type = getPreciseType(value);\n        if (type === 'symbol') {\n          return String(value);\n        }\n        return value;\n      });\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createObjectOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n      }\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n      }\n      for (var key in propValue) {\n        if (has(propValue, key)) {\n          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n          if (error instanceof Error) {\n            return error;\n          }\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createUnionTypeChecker(arrayOfTypeCheckers) {\n    if (!Array.isArray(arrayOfTypeCheckers)) {\n      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n      return emptyFunctionThatReturnsNull;\n    }\n\n    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n      var checker = arrayOfTypeCheckers[i];\n      if (typeof checker !== 'function') {\n        printWarning(\n          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\n          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'\n        );\n        return emptyFunctionThatReturnsNull;\n      }\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var expectedTypes = [];\n      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n        var checker = arrayOfTypeCheckers[i];\n        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);\n        if (checkerResult == null) {\n          return null;\n        }\n        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {\n          expectedTypes.push(checkerResult.data.expectedType);\n        }\n      }\n      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createNodeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!isNode(props[propName])) {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function invalidValidatorError(componentName, location, propFullName, key, type) {\n    return new PropTypeError(\n      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +\n      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'\n    );\n  }\n\n  function createShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      for (var key in shapeTypes) {\n        var checker = shapeTypes[key];\n        if (typeof checker !== 'function') {\n          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createStrictShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      // We need to check all keys in case some are required but missing from props.\n      var allKeys = assign({}, props[propName], shapeTypes);\n      for (var key in allKeys) {\n        var checker = shapeTypes[key];\n        if (has(shapeTypes, key) && typeof checker !== 'function') {\n          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));\n        }\n        if (!checker) {\n          return new PropTypeError(\n            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\n            '\\nBad object: ' + JSON.stringify(props[propName], null, '  ') +\n            '\\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')\n          );\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n\n    return createChainableTypeChecker(validate);\n  }\n\n  function isNode(propValue) {\n    switch (typeof propValue) {\n      case 'number':\n      case 'string':\n      case 'undefined':\n        return true;\n      case 'boolean':\n        return !propValue;\n      case 'object':\n        if (Array.isArray(propValue)) {\n          return propValue.every(isNode);\n        }\n        if (propValue === null || isValidElement(propValue)) {\n          return true;\n        }\n\n        var iteratorFn = getIteratorFn(propValue);\n        if (iteratorFn) {\n          var iterator = iteratorFn.call(propValue);\n          var step;\n          if (iteratorFn !== propValue.entries) {\n            while (!(step = iterator.next()).done) {\n              if (!isNode(step.value)) {\n                return false;\n              }\n            }\n          } else {\n            // Iterator will provide entry [k,v] tuples rather than values.\n            while (!(step = iterator.next()).done) {\n              var entry = step.value;\n              if (entry) {\n                if (!isNode(entry[1])) {\n                  return false;\n                }\n              }\n            }\n          }\n        } else {\n          return false;\n        }\n\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  function isSymbol(propType, propValue) {\n    // Native Symbol.\n    if (propType === 'symbol') {\n      return true;\n    }\n\n    // falsy value can't be a Symbol\n    if (!propValue) {\n      return false;\n    }\n\n    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n    if (propValue['@@toStringTag'] === 'Symbol') {\n      return true;\n    }\n\n    // Fallback for non-spec compliant Symbols which are polyfilled.\n    if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Equivalent of `typeof` but with special handling for array and regexp.\n  function getPropType(propValue) {\n    var propType = typeof propValue;\n    if (Array.isArray(propValue)) {\n      return 'array';\n    }\n    if (propValue instanceof RegExp) {\n      // Old webkits (at least until Android 4.0) return 'function' rather than\n      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n      // passes PropTypes.object.\n      return 'object';\n    }\n    if (isSymbol(propType, propValue)) {\n      return 'symbol';\n    }\n    return propType;\n  }\n\n  // This handles more types than `getPropType`. Only used for error messages.\n  // See `createPrimitiveTypeChecker`.\n  function getPreciseType(propValue) {\n    if (typeof propValue === 'undefined' || propValue === null) {\n      return '' + propValue;\n    }\n    var propType = getPropType(propValue);\n    if (propType === 'object') {\n      if (propValue instanceof Date) {\n        return 'date';\n      } else if (propValue instanceof RegExp) {\n        return 'regexp';\n      }\n    }\n    return propType;\n  }\n\n  // Returns a string that is postfixed to a warning about an invalid type.\n  // For example, \"undefined\" or \"of type array\"\n  function getPostfixForTypeWarning(value) {\n    var type = getPreciseType(value);\n    switch (type) {\n      case 'array':\n      case 'object':\n        return 'an ' + type;\n      case 'boolean':\n      case 'date':\n      case 'regexp':\n        return 'a ' + type;\n      default:\n        return type;\n    }\n  }\n\n  // Returns class name of the object, if any.\n  function getClassName(propValue) {\n    if (!propValue.constructor || !propValue.constructor.name) {\n      return ANONYMOUS;\n    }\n    return propValue.constructor.name;\n  }\n\n  ReactPropTypes.checkPropTypes = checkPropTypes;\n  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","module.exports = Function.call.bind(Object.prototype.hasOwnProperty);\n"],"names":["printWarning","ReactPropTypesSecret","loggedTypeFailures","has","checkPropTypes","typeSpecs","values","location","componentName","getStack","typeSpecName","error","err","Error","name","ex","message","stack","text","console","x","resetWarningCache","module","exports","ReactIs","assign","emptyFunctionThatReturnsNull","isValidElement","throwOnDirectAccess","ITERATOR_SYMBOL","Symbol","iterator","ANONYMOUS","ReactPropTypes","array","createPrimitiveTypeChecker","bigint","bool","func","number","object","string","symbol","any","createChainableTypeChecker","arrayOf","typeChecker","props","propName","propFullName","PropTypeError","propValue","Array","isArray","getPropType","i","length","element","elementType","isValidElementType","instanceOf","expectedClass","expectedClassName","constructor","node","isNode","objectOf","propType","key","oneOf","expectedValues","arguments","validate","is","valuesString","JSON","stringify","value","getPreciseType","String","oneOfType","arrayOfTypeCheckers","checker","getPostfixForTypeWarning","expectedTypes","checkerResult","data","push","expectedType","join","shape","shapeTypes","invalidValidatorError","exact","allKeys","Object","keys","y","this","manualPropTypeCallCache","manualPropTypeWarningCount","checkType","isRequired","secret","cacheKey","chainedCheckType","bind","type","every","iteratorFn","maybeIterable","getIteratorFn","step","call","entries","next","done","entry","RegExp","isSymbol","Date","prototype","PropTypes","isElement","Function","hasOwnProperty"],"sourceRoot":""}