| (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.PropTypes = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
| /** |
| * Copyright (c) 2013-present, Facebook, Inc. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| 'use strict'; |
| |
| var printWarning = function() {}; |
| |
| if ("development" !== 'production') { |
| var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); |
| var loggedTypeFailures = {}; |
| var has = Function.call.bind(Object.prototype.hasOwnProperty); |
| |
| printWarning = function(text) { |
| var message = 'Warning: ' + text; |
| if (typeof console !== 'undefined') { |
| console.error(message); |
| } |
| try { |
| // --- Welcome to debugging React --- |
| // This error was thrown as a convenience so that you can use this stack |
| // to find the callsite that caused this warning to fire. |
| throw new Error(message); |
| } catch (x) {} |
| }; |
| } |
| |
| /** |
| * Assert that the values match with the type specs. |
| * Error messages are memorized and will only be shown once. |
| * |
| * @param {object} typeSpecs Map of name to a ReactPropType |
| * @param {object} values Runtime values that need to be type-checked |
| * @param {string} location e.g. "prop", "context", "child context" |
| * @param {string} componentName Name of the component for error messages. |
| * @param {?Function} getStack Returns the component stack. |
| * @private |
| */ |
| function checkPropTypes(typeSpecs, values, location, componentName, getStack) { |
| if ("development" !== 'production') { |
| for (var typeSpecName in typeSpecs) { |
| if (has(typeSpecs, typeSpecName)) { |
| var error; |
| // Prop type validation may throw. In case they do, we don't want to |
| // fail the render phase where it didn't fail before. So we log it. |
| // After these have been cleaned up, we'll let them throw. |
| try { |
| // This is intentionally an invariant that gets caught. It's the same |
| // behavior as without this statement except with a better message. |
| if (typeof typeSpecs[typeSpecName] !== 'function') { |
| var err = Error( |
| (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + |
| 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' |
| ); |
| err.name = 'Invariant Violation'; |
| throw err; |
| } |
| error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); |
| } catch (ex) { |
| error = ex; |
| } |
| if (error && !(error instanceof Error)) { |
| printWarning( |
| (componentName || 'React class') + ': type specification of ' + |
| location + ' `' + typeSpecName + '` is invalid; the type checker ' + |
| 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + |
| 'You may have forgotten to pass an argument to the type checker ' + |
| 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + |
| 'shape all require an argument).' |
| ); |
| } |
| if (error instanceof Error && !(error.message in loggedTypeFailures)) { |
| // Only monitor this failure once because there tends to be a lot of the |
| // same error. |
| loggedTypeFailures[error.message] = true; |
| |
| var stack = getStack ? getStack() : ''; |
| |
| printWarning( |
| 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '') |
| ); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Resets warning cache when testing. |
| * |
| * @private |
| */ |
| checkPropTypes.resetWarningCache = function() { |
| if ("development" !== 'production') { |
| loggedTypeFailures = {}; |
| } |
| } |
| |
| module.exports = checkPropTypes; |
| |
| },{"./lib/ReactPropTypesSecret":5}],2:[function(require,module,exports){ |
| /** |
| * Copyright (c) 2013-present, Facebook, Inc. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| 'use strict'; |
| |
| var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); |
| |
| function emptyFunction() {} |
| function emptyFunctionWithReset() {} |
| emptyFunctionWithReset.resetWarningCache = emptyFunction; |
| |
| module.exports = function() { |
| function shim(props, propName, componentName, location, propFullName, secret) { |
| if (secret === ReactPropTypesSecret) { |
| // It is still safe when called from React. |
| return; |
| } |
| var err = new Error( |
| 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + |
| 'Use PropTypes.checkPropTypes() to call them. ' + |
| 'Read more at http://fb.me/use-check-prop-types' |
| ); |
| err.name = 'Invariant Violation'; |
| throw err; |
| }; |
| shim.isRequired = shim; |
| function getShim() { |
| return shim; |
| }; |
| // Important! |
| // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. |
| var ReactPropTypes = { |
| array: shim, |
| bool: shim, |
| func: shim, |
| number: shim, |
| object: shim, |
| string: shim, |
| symbol: shim, |
| |
| any: shim, |
| arrayOf: getShim, |
| element: shim, |
| elementType: shim, |
| instanceOf: getShim, |
| node: shim, |
| objectOf: getShim, |
| oneOf: getShim, |
| oneOfType: getShim, |
| shape: getShim, |
| exact: getShim, |
| |
| checkPropTypes: emptyFunctionWithReset, |
| resetWarningCache: emptyFunction |
| }; |
| |
| ReactPropTypes.PropTypes = ReactPropTypes; |
| |
| return ReactPropTypes; |
| }; |
| |
| },{"./lib/ReactPropTypesSecret":5}],3:[function(require,module,exports){ |
| /** |
| * Copyright (c) 2013-present, Facebook, Inc. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| 'use strict'; |
| |
| var ReactIs = require('react-is'); |
| var assign = require('object-assign'); |
| |
| var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret'); |
| var checkPropTypes = require('./checkPropTypes'); |
| |
| var has = Function.call.bind(Object.prototype.hasOwnProperty); |
| var printWarning = function() {}; |
| |
| if ("development" !== 'production') { |
| printWarning = function(text) { |
| var message = 'Warning: ' + text; |
| if (typeof console !== 'undefined') { |
| console.error(message); |
| } |
| try { |
| // --- Welcome to debugging React --- |
| // This error was thrown as a convenience so that you can use this stack |
| // to find the callsite that caused this warning to fire. |
| throw new Error(message); |
| } catch (x) {} |
| }; |
| } |
| |
| function emptyFunctionThatReturnsNull() { |
| return null; |
| } |
| |
| module.exports = function(isValidElement, throwOnDirectAccess) { |
| /* global Symbol */ |
| var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; |
| var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec. |
| |
| /** |
| * Returns the iterator method function contained on the iterable object. |
| * |
| * Be sure to invoke the function with the iterable as context: |
| * |
| * var iteratorFn = getIteratorFn(myIterable); |
| * if (iteratorFn) { |
| * var iterator = iteratorFn.call(myIterable); |
| * ... |
| * } |
| * |
| * @param {?object} maybeIterable |
| * @return {?function} |
| */ |
| function getIteratorFn(maybeIterable) { |
| var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); |
| if (typeof iteratorFn === 'function') { |
| return iteratorFn; |
| } |
| } |
| |
| /** |
| * Collection of methods that allow declaration and validation of props that are |
| * supplied to React components. Example usage: |
| * |
| * var Props = require('ReactPropTypes'); |
| * var MyArticle = React.createClass({ |
| * propTypes: { |
| * // An optional string prop named "description". |
| * description: Props.string, |
| * |
| * // A required enum prop named "category". |
| * category: Props.oneOf(['News','Photos']).isRequired, |
| * |
| * // A prop named "dialog" that requires an instance of Dialog. |
| * dialog: Props.instanceOf(Dialog).isRequired |
| * }, |
| * render: function() { ... } |
| * }); |
| * |
| * A more formal specification of how these methods are used: |
| * |
| * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...) |
| * decl := ReactPropTypes.{type}(.isRequired)? |
| * |
| * Each and every declaration produces a function with the same signature. This |
| * allows the creation of custom validation functions. For example: |
| * |
| * var MyLink = React.createClass({ |
| * propTypes: { |
| * // An optional string or URI prop named "href". |
| * href: function(props, propName, componentName) { |
| * var propValue = props[propName]; |
| * if (propValue != null && typeof propValue !== 'string' && |
| * !(propValue instanceof URI)) { |
| * return new Error( |
| * 'Expected a string or an URI for ' + propName + ' in ' + |
| * componentName |
| * ); |
| * } |
| * } |
| * }, |
| * render: function() {...} |
| * }); |
| * |
| * @internal |
| */ |
| |
| var ANONYMOUS = '<<anonymous>>'; |
| |
| // Important! |
| // Keep this list in sync with production version in `./factoryWithThrowingShims.js`. |
| var ReactPropTypes = { |
| array: createPrimitiveTypeChecker('array'), |
| bool: createPrimitiveTypeChecker('boolean'), |
| func: createPrimitiveTypeChecker('function'), |
| number: createPrimitiveTypeChecker('number'), |
| object: createPrimitiveTypeChecker('object'), |
| string: createPrimitiveTypeChecker('string'), |
| symbol: createPrimitiveTypeChecker('symbol'), |
| |
| any: createAnyTypeChecker(), |
| arrayOf: createArrayOfTypeChecker, |
| element: createElementTypeChecker(), |
| elementType: createElementTypeTypeChecker(), |
| instanceOf: createInstanceTypeChecker, |
| node: createNodeChecker(), |
| objectOf: createObjectOfTypeChecker, |
| oneOf: createEnumTypeChecker, |
| oneOfType: createUnionTypeChecker, |
| shape: createShapeTypeChecker, |
| exact: createStrictShapeTypeChecker, |
| }; |
| |
| /** |
| * inlined Object.is polyfill to avoid requiring consumers ship their own |
| * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is |
| */ |
| /*eslint-disable no-self-compare*/ |
| function is(x, y) { |
| // SameValue algorithm |
| if (x === y) { |
| // Steps 1-5, 7-10 |
| // Steps 6.b-6.e: +0 != -0 |
| return x !== 0 || 1 / x === 1 / y; |
| } else { |
| // Step 6.a: NaN == NaN |
| return x !== x && y !== y; |
| } |
| } |
| /*eslint-enable no-self-compare*/ |
| |
| /** |
| * We use an Error-like object for backward compatibility as people may call |
| * PropTypes directly and inspect their output. However, we don't use real |
| * Errors anymore. We don't inspect their stack anyway, and creating them |
| * is prohibitively expensive if they are created too often, such as what |
| * happens in oneOfType() for any type before the one that matched. |
| */ |
| function PropTypeError(message) { |
| this.message = message; |
| this.stack = ''; |
| } |
| // Make `instanceof Error` still work for returned errors. |
| PropTypeError.prototype = Error.prototype; |
| |
| function createChainableTypeChecker(validate) { |
| if ("development" !== 'production') { |
| var manualPropTypeCallCache = {}; |
| var manualPropTypeWarningCount = 0; |
| } |
| function checkType(isRequired, props, propName, componentName, location, propFullName, secret) { |
| componentName = componentName || ANONYMOUS; |
| propFullName = propFullName || propName; |
| |
| if (secret !== ReactPropTypesSecret) { |
| if (throwOnDirectAccess) { |
| // New behavior only for users of `prop-types` package |
| var err = new Error( |
| 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + |
| 'Use `PropTypes.checkPropTypes()` to call them. ' + |
| 'Read more at http://fb.me/use-check-prop-types' |
| ); |
| err.name = 'Invariant Violation'; |
| throw err; |
| } else if ("development" !== 'production' && typeof console !== 'undefined') { |
| // Old behavior for people using React.PropTypes |
| var cacheKey = componentName + ':' + propName; |
| if ( |
| !manualPropTypeCallCache[cacheKey] && |
| // Avoid spamming the console because they are often not actionable except for lib authors |
| manualPropTypeWarningCount < 3 |
| ) { |
| printWarning( |
| 'You are manually calling a React.PropTypes validation ' + |
| 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' + |
| 'and will throw in the standalone `prop-types` package. ' + |
| 'You may be seeing this warning due to a third-party PropTypes ' + |
| 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.' |
| ); |
| manualPropTypeCallCache[cacheKey] = true; |
| manualPropTypeWarningCount++; |
| } |
| } |
| } |
| if (props[propName] == null) { |
| if (isRequired) { |
| if (props[propName] === null) { |
| return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.')); |
| } |
| return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.')); |
| } |
| return null; |
| } else { |
| return validate(props, propName, componentName, location, propFullName); |
| } |
| } |
| |
| var chainedCheckType = checkType.bind(null, false); |
| chainedCheckType.isRequired = checkType.bind(null, true); |
| |
| return chainedCheckType; |
| } |
| |
| function createPrimitiveTypeChecker(expectedType) { |
| function validate(props, propName, componentName, location, propFullName, secret) { |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== expectedType) { |
| // `propValue` being instance of, say, date/regexp, pass the 'object' |
| // check, but we can offer a more precise error message here rather than |
| // 'of type `object`'. |
| var preciseType = getPreciseType(propValue); |
| |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createAnyTypeChecker() { |
| return createChainableTypeChecker(emptyFunctionThatReturnsNull); |
| } |
| |
| function createArrayOfTypeChecker(typeChecker) { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (typeof typeChecker !== 'function') { |
| return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.'); |
| } |
| var propValue = props[propName]; |
| if (!Array.isArray(propValue)) { |
| var propType = getPropType(propValue); |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.')); |
| } |
| for (var i = 0; i < propValue.length; i++) { |
| var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret); |
| if (error instanceof Error) { |
| return error; |
| } |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createElementTypeChecker() { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| if (!isValidElement(propValue)) { |
| var propType = getPropType(propValue); |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createElementTypeTypeChecker() { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| if (!ReactIs.isValidElementType(propValue)) { |
| var propType = getPropType(propValue); |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createInstanceTypeChecker(expectedClass) { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (!(props[propName] instanceof expectedClass)) { |
| var expectedClassName = expectedClass.name || ANONYMOUS; |
| var actualClassName = getClassName(props[propName]); |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createEnumTypeChecker(expectedValues) { |
| if (!Array.isArray(expectedValues)) { |
| if ("development" !== 'production') { |
| if (arguments.length > 1) { |
| printWarning( |
| 'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + |
| 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).' |
| ); |
| } else { |
| printWarning('Invalid argument supplied to oneOf, expected an array.'); |
| } |
| } |
| return emptyFunctionThatReturnsNull; |
| } |
| |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| for (var i = 0; i < expectedValues.length; i++) { |
| if (is(propValue, expectedValues[i])) { |
| return null; |
| } |
| } |
| |
| var valuesString = JSON.stringify(expectedValues, function replacer(key, value) { |
| var type = getPreciseType(value); |
| if (type === 'symbol') { |
| return String(value); |
| } |
| return value; |
| }); |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.')); |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createObjectOfTypeChecker(typeChecker) { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (typeof typeChecker !== 'function') { |
| return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.'); |
| } |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== 'object') { |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.')); |
| } |
| for (var key in propValue) { |
| if (has(propValue, key)) { |
| var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); |
| if (error instanceof Error) { |
| return error; |
| } |
| } |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createUnionTypeChecker(arrayOfTypeCheckers) { |
| if (!Array.isArray(arrayOfTypeCheckers)) { |
| "development" !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0; |
| return emptyFunctionThatReturnsNull; |
| } |
| |
| for (var i = 0; i < arrayOfTypeCheckers.length; i++) { |
| var checker = arrayOfTypeCheckers[i]; |
| if (typeof checker !== 'function') { |
| printWarning( |
| 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + |
| 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.' |
| ); |
| return emptyFunctionThatReturnsNull; |
| } |
| } |
| |
| function validate(props, propName, componentName, location, propFullName) { |
| for (var i = 0; i < arrayOfTypeCheckers.length; i++) { |
| var checker = arrayOfTypeCheckers[i]; |
| if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) { |
| return null; |
| } |
| } |
| |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.')); |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createNodeChecker() { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (!isNode(props[propName])) { |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createShapeTypeChecker(shapeTypes) { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== 'object') { |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); |
| } |
| for (var key in shapeTypes) { |
| var checker = shapeTypes[key]; |
| if (!checker) { |
| continue; |
| } |
| var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); |
| if (error) { |
| return error; |
| } |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createStrictShapeTypeChecker(shapeTypes) { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== 'object') { |
| return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); |
| } |
| // We need to check all keys in case some are required but missing from |
| // props. |
| var allKeys = assign({}, props[propName], shapeTypes); |
| for (var key in allKeys) { |
| var checker = shapeTypes[key]; |
| if (!checker) { |
| return new PropTypeError( |
| 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + |
| '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + |
| '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ') |
| ); |
| } |
| var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret); |
| if (error) { |
| return error; |
| } |
| } |
| return null; |
| } |
| |
| return createChainableTypeChecker(validate); |
| } |
| |
| function isNode(propValue) { |
| switch (typeof propValue) { |
| case 'number': |
| case 'string': |
| case 'undefined': |
| return true; |
| case 'boolean': |
| return !propValue; |
| case 'object': |
| if (Array.isArray(propValue)) { |
| return propValue.every(isNode); |
| } |
| if (propValue === null || isValidElement(propValue)) { |
| return true; |
| } |
| |
| var iteratorFn = getIteratorFn(propValue); |
| if (iteratorFn) { |
| var iterator = iteratorFn.call(propValue); |
| var step; |
| if (iteratorFn !== propValue.entries) { |
| while (!(step = iterator.next()).done) { |
| if (!isNode(step.value)) { |
| return false; |
| } |
| } |
| } else { |
| // Iterator will provide entry [k,v] tuples rather than values. |
| while (!(step = iterator.next()).done) { |
| var entry = step.value; |
| if (entry) { |
| if (!isNode(entry[1])) { |
| return false; |
| } |
| } |
| } |
| } |
| } else { |
| return false; |
| } |
| |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| function isSymbol(propType, propValue) { |
| // Native Symbol. |
| if (propType === 'symbol') { |
| return true; |
| } |
| |
| // falsy value can't be a Symbol |
| if (!propValue) { |
| return false; |
| } |
| |
| // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol' |
| if (propValue['@@toStringTag'] === 'Symbol') { |
| return true; |
| } |
| |
| // Fallback for non-spec compliant Symbols which are polyfilled. |
| if (typeof Symbol === 'function' && propValue instanceof Symbol) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| // Equivalent of `typeof` but with special handling for array and regexp. |
| function getPropType(propValue) { |
| var propType = typeof propValue; |
| if (Array.isArray(propValue)) { |
| return 'array'; |
| } |
| if (propValue instanceof RegExp) { |
| // Old webkits (at least until Android 4.0) return 'function' rather than |
| // 'object' for typeof a RegExp. We'll normalize this here so that /bla/ |
| // passes PropTypes.object. |
| return 'object'; |
| } |
| if (isSymbol(propType, propValue)) { |
| return 'symbol'; |
| } |
| return propType; |
| } |
| |
| // This handles more types than `getPropType`. Only used for error messages. |
| // See `createPrimitiveTypeChecker`. |
| function getPreciseType(propValue) { |
| if (typeof propValue === 'undefined' || propValue === null) { |
| return '' + propValue; |
| } |
| var propType = getPropType(propValue); |
| if (propType === 'object') { |
| if (propValue instanceof Date) { |
| return 'date'; |
| } else if (propValue instanceof RegExp) { |
| return 'regexp'; |
| } |
| } |
| return propType; |
| } |
| |
| // Returns a string that is postfixed to a warning about an invalid type. |
| // For example, "undefined" or "of type array" |
| function getPostfixForTypeWarning(value) { |
| var type = getPreciseType(value); |
| switch (type) { |
| case 'array': |
| case 'object': |
| return 'an ' + type; |
| case 'boolean': |
| case 'date': |
| case 'regexp': |
| return 'a ' + type; |
| default: |
| return type; |
| } |
| } |
| |
| // Returns class name of the object, if any. |
| function getClassName(propValue) { |
| if (!propValue.constructor || !propValue.constructor.name) { |
| return ANONYMOUS; |
| } |
| return propValue.constructor.name; |
| } |
| |
| ReactPropTypes.checkPropTypes = checkPropTypes; |
| ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache; |
| ReactPropTypes.PropTypes = ReactPropTypes; |
| |
| return ReactPropTypes; |
| }; |
| |
| },{"./checkPropTypes":1,"./lib/ReactPropTypesSecret":5,"object-assign":6,"react-is":10}],4:[function(require,module,exports){ |
| /** |
| * Copyright (c) 2013-present, Facebook, Inc. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| if ("development" !== 'production') { |
| var ReactIs = require('react-is'); |
| |
| // By explicitly using `prop-types` you are opting into new development behavior. |
| // http://fb.me/prop-types-in-prod |
| var throwOnDirectAccess = true; |
| module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess); |
| } else { |
| // By explicitly using `prop-types` you are opting into new production behavior. |
| // http://fb.me/prop-types-in-prod |
| module.exports = require('./factoryWithThrowingShims')(); |
| } |
| |
| },{"./factoryWithThrowingShims":2,"./factoryWithTypeCheckers":3,"react-is":10}],5:[function(require,module,exports){ |
| /** |
| * Copyright (c) 2013-present, Facebook, Inc. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| 'use strict'; |
| |
| var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; |
| |
| module.exports = ReactPropTypesSecret; |
| |
| },{}],6:[function(require,module,exports){ |
| /* |
| object-assign |
| (c) Sindre Sorhus |
| @license MIT |
| */ |
| |
| 'use strict'; |
| /* eslint-disable no-unused-vars */ |
| var getOwnPropertySymbols = Object.getOwnPropertySymbols; |
| var hasOwnProperty = Object.prototype.hasOwnProperty; |
| var propIsEnumerable = Object.prototype.propertyIsEnumerable; |
| |
| function toObject(val) { |
| if (val === null || val === undefined) { |
| throw new TypeError('Object.assign cannot be called with null or undefined'); |
| } |
| |
| return Object(val); |
| } |
| |
| function shouldUseNative() { |
| try { |
| if (!Object.assign) { |
| return false; |
| } |
| |
| // Detect buggy property enumeration order in older V8 versions. |
| |
| // https://bugs.chromium.org/p/v8/issues/detail?id=4118 |
| var test1 = new String('abc'); // eslint-disable-line no-new-wrappers |
| test1[5] = 'de'; |
| if (Object.getOwnPropertyNames(test1)[0] === '5') { |
| return false; |
| } |
| |
| // https://bugs.chromium.org/p/v8/issues/detail?id=3056 |
| var test2 = {}; |
| for (var i = 0; i < 10; i++) { |
| test2['_' + String.fromCharCode(i)] = i; |
| } |
| var order2 = Object.getOwnPropertyNames(test2).map(function (n) { |
| return test2[n]; |
| }); |
| if (order2.join('') !== '0123456789') { |
| return false; |
| } |
| |
| // https://bugs.chromium.org/p/v8/issues/detail?id=3056 |
| var test3 = {}; |
| 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { |
| test3[letter] = letter; |
| }); |
| if (Object.keys(Object.assign({}, test3)).join('') !== |
| 'abcdefghijklmnopqrst') { |
| return false; |
| } |
| |
| return true; |
| } catch (err) { |
| // We don't expect any of the above to throw, but better to be safe. |
| return false; |
| } |
| } |
| |
| module.exports = shouldUseNative() ? Object.assign : function (target, source) { |
| var from; |
| var to = toObject(target); |
| var symbols; |
| |
| for (var s = 1; s < arguments.length; s++) { |
| from = Object(arguments[s]); |
| |
| for (var key in from) { |
| if (hasOwnProperty.call(from, key)) { |
| to[key] = from[key]; |
| } |
| } |
| |
| if (getOwnPropertySymbols) { |
| symbols = getOwnPropertySymbols(from); |
| for (var i = 0; i < symbols.length; i++) { |
| if (propIsEnumerable.call(from, symbols[i])) { |
| to[symbols[i]] = from[symbols[i]]; |
| } |
| } |
| } |
| } |
| |
| return to; |
| }; |
| |
| },{}],7:[function(require,module,exports){ |
| // shim for using process in browser |
| var process = module.exports = {}; |
| |
| // cached from whatever global is present so that test runners that stub it |
| // don't break things. But we need to wrap it in a try catch in case it is |
| // wrapped in strict mode code which doesn't define any globals. It's inside a |
| // function because try/catches deoptimize in certain engines. |
| |
| var cachedSetTimeout; |
| var cachedClearTimeout; |
| |
| function defaultSetTimout() { |
| throw new Error('setTimeout has not been defined'); |
| } |
| function defaultClearTimeout () { |
| throw new Error('clearTimeout has not been defined'); |
| } |
| (function () { |
| try { |
| if (typeof setTimeout === 'function') { |
| cachedSetTimeout = setTimeout; |
| } else { |
| cachedSetTimeout = defaultSetTimout; |
| } |
| } catch (e) { |
| cachedSetTimeout = defaultSetTimout; |
| } |
| try { |
| if (typeof clearTimeout === 'function') { |
| cachedClearTimeout = clearTimeout; |
| } else { |
| cachedClearTimeout = defaultClearTimeout; |
| } |
| } catch (e) { |
| cachedClearTimeout = defaultClearTimeout; |
| } |
| } ()) |
| function runTimeout(fun) { |
| if (cachedSetTimeout === setTimeout) { |
| //normal enviroments in sane situations |
| return setTimeout(fun, 0); |
| } |
| // if setTimeout wasn't available but was latter defined |
| if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { |
| cachedSetTimeout = setTimeout; |
| return setTimeout(fun, 0); |
| } |
| try { |
| // when when somebody has screwed with setTimeout but no I.E. maddness |
| return cachedSetTimeout(fun, 0); |
| } catch(e){ |
| try { |
| // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally |
| return cachedSetTimeout.call(null, fun, 0); |
| } catch(e){ |
| // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error |
| return cachedSetTimeout.call(this, fun, 0); |
| } |
| } |
| |
| |
| } |
| function runClearTimeout(marker) { |
| if (cachedClearTimeout === clearTimeout) { |
| //normal enviroments in sane situations |
| return clearTimeout(marker); |
| } |
| // if clearTimeout wasn't available but was latter defined |
| if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { |
| cachedClearTimeout = clearTimeout; |
| return clearTimeout(marker); |
| } |
| try { |
| // when when somebody has screwed with setTimeout but no I.E. maddness |
| return cachedClearTimeout(marker); |
| } catch (e){ |
| try { |
| // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally |
| return cachedClearTimeout.call(null, marker); |
| } catch (e){ |
| // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. |
| // Some versions of I.E. have different rules for clearTimeout vs setTimeout |
| return cachedClearTimeout.call(this, marker); |
| } |
| } |
| |
| |
| |
| } |
| var queue = []; |
| var draining = false; |
| var currentQueue; |
| var queueIndex = -1; |
| |
| function cleanUpNextTick() { |
| if (!draining || !currentQueue) { |
| return; |
| } |
| draining = false; |
| if (currentQueue.length) { |
| queue = currentQueue.concat(queue); |
| } else { |
| queueIndex = -1; |
| } |
| if (queue.length) { |
| drainQueue(); |
| } |
| } |
| |
| function drainQueue() { |
| if (draining) { |
| return; |
| } |
| var timeout = runTimeout(cleanUpNextTick); |
| draining = true; |
| |
| var len = queue.length; |
| while(len) { |
| currentQueue = queue; |
| queue = []; |
| while (++queueIndex < len) { |
| if (currentQueue) { |
| currentQueue[queueIndex].run(); |
| } |
| } |
| queueIndex = -1; |
| len = queue.length; |
| } |
| currentQueue = null; |
| draining = false; |
| runClearTimeout(timeout); |
| } |
| |
| process.nextTick = function (fun) { |
| var args = new Array(arguments.length - 1); |
| if (arguments.length > 1) { |
| for (var i = 1; i < arguments.length; i++) { |
| args[i - 1] = arguments[i]; |
| } |
| } |
| queue.push(new Item(fun, args)); |
| if (queue.length === 1 && !draining) { |
| runTimeout(drainQueue); |
| } |
| }; |
| |
| // v8 likes predictible objects |
| function Item(fun, array) { |
| this.fun = fun; |
| this.array = array; |
| } |
| Item.prototype.run = function () { |
| this.fun.apply(null, this.array); |
| }; |
| process.title = 'browser'; |
| process.browser = true; |
| process.env = {}; |
| process.argv = []; |
| process.version = ''; // empty string to avoid regexp issues |
| process.versions = {}; |
| |
| function noop() {} |
| |
| process.on = noop; |
| process.addListener = noop; |
| process.once = noop; |
| process.off = noop; |
| process.removeListener = noop; |
| process.removeAllListeners = noop; |
| process.emit = noop; |
| process.prependListener = noop; |
| process.prependOnceListener = noop; |
| |
| process.listeners = function (name) { return [] } |
| |
| process.binding = function (name) { |
| throw new Error('process.binding is not supported'); |
| }; |
| |
| process.cwd = function () { return '/' }; |
| process.chdir = function (dir) { |
| throw new Error('process.chdir is not supported'); |
| }; |
| process.umask = function() { return 0; }; |
| |
| },{}],8:[function(require,module,exports){ |
| (function (process){ |
| /** @license React v16.8.1 |
| * react-is.development.js |
| * |
| * Copyright (c) Facebook, Inc. and its affiliates. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| 'use strict'; |
| |
| |
| |
| if (process.env.NODE_ENV !== "production") { |
| (function() { |
| 'use strict'; |
| |
| Object.defineProperty(exports, '__esModule', { value: true }); |
| |
| // The Symbol used to tag the ReactElement-like types. If there is no native Symbol |
| // nor polyfill, then a plain number is used for performance. |
| var hasSymbol = typeof Symbol === 'function' && Symbol.for; |
| |
| var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7; |
| var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca; |
| var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb; |
| var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc; |
| var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2; |
| var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd; |
| var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; |
| var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf; |
| var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf; |
| var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0; |
| var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1; |
| var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3; |
| var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4; |
| |
| function isValidElementType(type) { |
| return typeof type === 'string' || typeof type === 'function' || |
| // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill. |
| type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE); |
| } |
| |
| /** |
| * Forked from fbjs/warning: |
| * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js |
| * |
| * Only change is we use console.warn instead of console.error, |
| * and do nothing when 'console' is not supported. |
| * This really simplifies the code. |
| * --- |
| * Similar to invariant but only logs a warning if the condition is not met. |
| * This can be used to log issues in development environments in critical |
| * paths. Removing the logging code for production environments will keep the |
| * same logic and follow the same code paths. |
| */ |
| |
| var lowPriorityWarning = function () {}; |
| |
| { |
| var printWarning = function (format) { |
| for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
| args[_key - 1] = arguments[_key]; |
| } |
| |
| var argIndex = 0; |
| var message = 'Warning: ' + format.replace(/%s/g, function () { |
| return args[argIndex++]; |
| }); |
| if (typeof console !== 'undefined') { |
| console.warn(message); |
| } |
| try { |
| // --- Welcome to debugging React --- |
| // This error was thrown as a convenience so that you can use this stack |
| // to find the callsite that caused this warning to fire. |
| throw new Error(message); |
| } catch (x) {} |
| }; |
| |
| lowPriorityWarning = function (condition, format) { |
| if (format === undefined) { |
| throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument'); |
| } |
| if (!condition) { |
| for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { |
| args[_key2 - 2] = arguments[_key2]; |
| } |
| |
| printWarning.apply(undefined, [format].concat(args)); |
| } |
| }; |
| } |
| |
| var lowPriorityWarning$1 = lowPriorityWarning; |
| |
| function typeOf(object) { |
| if (typeof object === 'object' && object !== null) { |
| var $$typeof = object.$$typeof; |
| switch ($$typeof) { |
| case REACT_ELEMENT_TYPE: |
| var type = object.type; |
| |
| switch (type) { |
| case REACT_ASYNC_MODE_TYPE: |
| case REACT_CONCURRENT_MODE_TYPE: |
| case REACT_FRAGMENT_TYPE: |
| case REACT_PROFILER_TYPE: |
| case REACT_STRICT_MODE_TYPE: |
| case REACT_SUSPENSE_TYPE: |
| return type; |
| default: |
| var $$typeofType = type && type.$$typeof; |
| |
| switch ($$typeofType) { |
| case REACT_CONTEXT_TYPE: |
| case REACT_FORWARD_REF_TYPE: |
| case REACT_PROVIDER_TYPE: |
| return $$typeofType; |
| default: |
| return $$typeof; |
| } |
| } |
| case REACT_LAZY_TYPE: |
| case REACT_MEMO_TYPE: |
| case REACT_PORTAL_TYPE: |
| return $$typeof; |
| } |
| } |
| |
| return undefined; |
| } |
| |
| // AsyncMode is deprecated along with isAsyncMode |
| var AsyncMode = REACT_ASYNC_MODE_TYPE; |
| var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE; |
| var ContextConsumer = REACT_CONTEXT_TYPE; |
| var ContextProvider = REACT_PROVIDER_TYPE; |
| var Element = REACT_ELEMENT_TYPE; |
| var ForwardRef = REACT_FORWARD_REF_TYPE; |
| var Fragment = REACT_FRAGMENT_TYPE; |
| var Lazy = REACT_LAZY_TYPE; |
| var Memo = REACT_MEMO_TYPE; |
| var Portal = REACT_PORTAL_TYPE; |
| var Profiler = REACT_PROFILER_TYPE; |
| var StrictMode = REACT_STRICT_MODE_TYPE; |
| var Suspense = REACT_SUSPENSE_TYPE; |
| |
| var hasWarnedAboutDeprecatedIsAsyncMode = false; |
| |
| // AsyncMode should be deprecated |
| function isAsyncMode(object) { |
| { |
| if (!hasWarnedAboutDeprecatedIsAsyncMode) { |
| hasWarnedAboutDeprecatedIsAsyncMode = true; |
| lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.'); |
| } |
| } |
| return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE; |
| } |
| function isConcurrentMode(object) { |
| return typeOf(object) === REACT_CONCURRENT_MODE_TYPE; |
| } |
| function isContextConsumer(object) { |
| return typeOf(object) === REACT_CONTEXT_TYPE; |
| } |
| function isContextProvider(object) { |
| return typeOf(object) === REACT_PROVIDER_TYPE; |
| } |
| function isElement(object) { |
| return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; |
| } |
| function isForwardRef(object) { |
| return typeOf(object) === REACT_FORWARD_REF_TYPE; |
| } |
| function isFragment(object) { |
| return typeOf(object) === REACT_FRAGMENT_TYPE; |
| } |
| function isLazy(object) { |
| return typeOf(object) === REACT_LAZY_TYPE; |
| } |
| function isMemo(object) { |
| return typeOf(object) === REACT_MEMO_TYPE; |
| } |
| function isPortal(object) { |
| return typeOf(object) === REACT_PORTAL_TYPE; |
| } |
| function isProfiler(object) { |
| return typeOf(object) === REACT_PROFILER_TYPE; |
| } |
| function isStrictMode(object) { |
| return typeOf(object) === REACT_STRICT_MODE_TYPE; |
| } |
| function isSuspense(object) { |
| return typeOf(object) === REACT_SUSPENSE_TYPE; |
| } |
| |
| exports.typeOf = typeOf; |
| exports.AsyncMode = AsyncMode; |
| exports.ConcurrentMode = ConcurrentMode; |
| exports.ContextConsumer = ContextConsumer; |
| exports.ContextProvider = ContextProvider; |
| exports.Element = Element; |
| exports.ForwardRef = ForwardRef; |
| exports.Fragment = Fragment; |
| exports.Lazy = Lazy; |
| exports.Memo = Memo; |
| exports.Portal = Portal; |
| exports.Profiler = Profiler; |
| exports.StrictMode = StrictMode; |
| exports.Suspense = Suspense; |
| exports.isValidElementType = isValidElementType; |
| exports.isAsyncMode = isAsyncMode; |
| exports.isConcurrentMode = isConcurrentMode; |
| exports.isContextConsumer = isContextConsumer; |
| exports.isContextProvider = isContextProvider; |
| exports.isElement = isElement; |
| exports.isForwardRef = isForwardRef; |
| exports.isFragment = isFragment; |
| exports.isLazy = isLazy; |
| exports.isMemo = isMemo; |
| exports.isPortal = isPortal; |
| exports.isProfiler = isProfiler; |
| exports.isStrictMode = isStrictMode; |
| exports.isSuspense = isSuspense; |
| })(); |
| } |
| |
| }).call(this,require('_process')) |
| },{"_process":7}],9:[function(require,module,exports){ |
| /** @license React v16.8.1 |
| * react-is.production.min.js |
| * |
| * Copyright (c) Facebook, Inc. and its affiliates. |
| * |
| * This source code is licensed under the MIT license found in the |
| * LICENSE file in the root directory of this source tree. |
| */ |
| |
| 'use strict';Object.defineProperty(exports,"__esModule",{value:!0}); |
| var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?Symbol.for("react.memo"): |
| 60115,r=b?Symbol.for("react.lazy"):60116;function t(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case h:return a;default:return u}}case r:case q:case d:return u}}}function v(a){return t(a)===m}exports.typeOf=t;exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n; |
| exports.Fragment=e;exports.Lazy=r;exports.Memo=q;exports.Portal=d;exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||"object"===typeof a&&null!==a&&(a.$$typeof===r||a.$$typeof===q||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n)};exports.isAsyncMode=function(a){return v(a)||t(a)===l};exports.isConcurrentMode=v;exports.isContextConsumer=function(a){return t(a)===k}; |
| exports.isContextProvider=function(a){return t(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return t(a)===n};exports.isFragment=function(a){return t(a)===e};exports.isLazy=function(a){return t(a)===r};exports.isMemo=function(a){return t(a)===q};exports.isPortal=function(a){return t(a)===d};exports.isProfiler=function(a){return t(a)===g};exports.isStrictMode=function(a){return t(a)===f}; |
| exports.isSuspense=function(a){return t(a)===p}; |
| |
| },{}],10:[function(require,module,exports){ |
| (function (process){ |
| 'use strict'; |
| |
| if (process.env.NODE_ENV === 'production') { |
| module.exports = require('./cjs/react-is.production.min.js'); |
| } else { |
| module.exports = require('./cjs/react-is.development.js'); |
| } |
| |
| }).call(this,require('_process')) |
| },{"./cjs/react-is.development.js":8,"./cjs/react-is.production.min.js":9,"_process":7}]},{},[4])(4) |
| }); |