{"version":3,"sources":["node_modules\\create-react-class\\factory.js"],"names":["_assign","require","emptyObject","_invariant","process","env","NODE_ENV","warning","MIXINS_KEY","identity","fn","ReactPropTypeLocationNames","prop","context","childContext","factory","ReactComponent","isValidElement","ReactNoopUpdateQueue","injectedMixins","ReactClassInterface","mixins","statics","propTypes","contextTypes","childContextTypes","getDefaultProps","getInitialState","getChildContext","render","componentWillMount","componentDidMount","componentWillReceiveProps","shouldComponentUpdate","componentWillUpdate","componentDidUpdate","componentWillUnmount","updateComponent","RESERVED_SPEC_KEYS","displayName","Constructor","i","length","mixSpecIntoComponent","validateTypeDef","createMergedResultFunction","mixStaticSpecIntoComponent","autobind","typeDef","location","propName","hasOwnProperty","validateMethodOverride","isAlreadyDefined","name","specPolicy","ReactClassMixin","spec","typeofSpec","isMixinValid","proto","prototype","autoBindPairs","__reactAutoBindPairs","property","isReactClassMethod","isFunction","shouldAutoBind","push","createChainedFunction","isReserved","isInherited","mergeIntoWithNoDuplicateKeys","one","two","key","undefined","mergedResult","a","apply","arguments","b","c","chainedFunction","bindAutoBindMethod","component","method","boundMethod","bind","__reactBoundContext","__reactBoundMethod","__reactBoundArguments","componentName","constructor","_bind","newThis","_len","args","Array","_key","reboundMethod","bindAutoBindMethods","pairs","autoBindKey","IsMountedPreMixin","__isMounted","IsMountedPostMixin","replaceState","newState","callback","updater","enqueueReplaceState","isMounted","__didWarnIsMounted","ReactClassComponent","createClass","props","refs","state","initialState","_isMockFunction","isArray","forEach","defaultProps","isReactClassApproved","componentShouldUpdate","componentWillRecieveProps","methodName","module","exports"],"mappings":"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","file":"factory.js","sourceRoot":"d:/Work/Office/react-native-on-web/cli/tmpl/project","sourcesContent":["/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar _invariant = require('fbjs/lib/invariant');\n\nif (process.env.NODE_ENV !== 'production') {\n  var warning = require('fbjs/lib/warning');\n}\n\nvar MIXINS_KEY = 'mixins';\n\n// Helper function to allow the creation of anonymous functions which do not\n// have .name set to the name of the variable being assigned to.\nfunction identity(fn) {\n  return fn;\n}\n\nvar ReactPropTypeLocationNames;\nif (process.env.NODE_ENV !== 'production') {\n  ReactPropTypeLocationNames = {\n    prop: 'prop',\n    context: 'context',\n    childContext: 'child context'\n  };\n} else {\n  ReactPropTypeLocationNames = {};\n}\n\nfunction factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {\n  /**\n   * Policies that describe methods in `ReactClassInterface`.\n   */\n\n  var injectedMixins = [];\n\n  /**\n   * Composite components are higher-level components that compose other composite\n   * or host components.\n   *\n   * To create a new type of `ReactClass`, pass a specification of\n   * your new class to `React.createClass`. The only requirement of your class\n   * specification is that you implement a `render` method.\n   *\n   *   var MyComponent = React.createClass({\n   *     render: function() {\n   *       return <div>Hello World</div>;\n   *     }\n   *   });\n   *\n   * The class specification supports a specific protocol of methods that have\n   * special meaning (e.g. `render`). See `ReactClassInterface` for\n   * more the comprehensive protocol. Any other properties and methods in the\n   * class specification will be available on the prototype.\n   *\n   * @interface ReactClassInterface\n   * @internal\n   */\n  var ReactClassInterface = {\n    /**\n     * An array of Mixin objects to include when defining your component.\n     *\n     * @type {array}\n     * @optional\n     */\n    mixins: 'DEFINE_MANY',\n\n    /**\n     * An object containing properties and methods that should be defined on\n     * the component's constructor instead of its prototype (static methods).\n     *\n     * @type {object}\n     * @optional\n     */\n    statics: 'DEFINE_MANY',\n\n    /**\n     * Definition of prop types for this component.\n     *\n     * @type {object}\n     * @optional\n     */\n    propTypes: 'DEFINE_MANY',\n\n    /**\n     * Definition of context types for this component.\n     *\n     * @type {object}\n     * @optional\n     */\n    contextTypes: 'DEFINE_MANY',\n\n    /**\n     * Definition of context types this component sets for its children.\n     *\n     * @type {object}\n     * @optional\n     */\n    childContextTypes: 'DEFINE_MANY',\n\n    // ==== Definition methods ====\n\n    /**\n     * Invoked when the component is mounted. Values in the mapping will be set on\n     * `this.props` if that prop is not specified (i.e. using an `in` check).\n     *\n     * This method is invoked before `getInitialState` and therefore cannot rely\n     * on `this.state` or use `this.setState`.\n     *\n     * @return {object}\n     * @optional\n     */\n    getDefaultProps: 'DEFINE_MANY_MERGED',\n\n    /**\n     * Invoked once before the component is mounted. The return value will be used\n     * as the initial value of `this.state`.\n     *\n     *   getInitialState: function() {\n     *     return {\n     *       isOn: false,\n     *       fooBaz: new BazFoo()\n     *     }\n     *   }\n     *\n     * @return {object}\n     * @optional\n     */\n    getInitialState: 'DEFINE_MANY_MERGED',\n\n    /**\n     * @return {object}\n     * @optional\n     */\n    getChildContext: 'DEFINE_MANY_MERGED',\n\n    /**\n     * Uses props from `this.props` and state from `this.state` to render the\n     * structure of the component.\n     *\n     * No guarantees are made about when or how often this method is invoked, so\n     * it must not have side effects.\n     *\n     *   render: function() {\n     *     var name = this.props.name;\n     *     return <div>Hello, {name}!</div>;\n     *   }\n     *\n     * @return {ReactComponent}\n     * @required\n     */\n    render: 'DEFINE_ONCE',\n\n    // ==== Delegate methods ====\n\n    /**\n     * Invoked when the component is initially created and about to be mounted.\n     * This may have side effects, but any external subscriptions or data created\n     * by this method must be cleaned up in `componentWillUnmount`.\n     *\n     * @optional\n     */\n    componentWillMount: 'DEFINE_MANY',\n\n    /**\n     * Invoked when the component has been mounted and has a DOM representation.\n     * However, there is no guarantee that the DOM node is in the document.\n     *\n     * Use this as an opportunity to operate on the DOM when the component has\n     * been mounted (initialized and rendered) for the first time.\n     *\n     * @param {DOMElement} rootNode DOM element representing the component.\n     * @optional\n     */\n    componentDidMount: 'DEFINE_MANY',\n\n    /**\n     * Invoked before the component receives new props.\n     *\n     * Use this as an opportunity to react to a prop transition by updating the\n     * state using `this.setState`. Current props are accessed via `this.props`.\n     *\n     *   componentWillReceiveProps: function(nextProps, nextContext) {\n     *     this.setState({\n     *       likesIncreasing: nextProps.likeCount > this.props.likeCount\n     *     });\n     *   }\n     *\n     * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop\n     * transition may cause a state change, but the opposite is not true. If you\n     * need it, you are probably looking for `componentWillUpdate`.\n     *\n     * @param {object} nextProps\n     * @optional\n     */\n    componentWillReceiveProps: 'DEFINE_MANY',\n\n    /**\n     * Invoked while deciding if the component should be updated as a result of\n     * receiving new props, state and/or context.\n     *\n     * Use this as an opportunity to `return false` when you're certain that the\n     * transition to the new props/state/context will not require a component\n     * update.\n     *\n     *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {\n     *     return !equal(nextProps, this.props) ||\n     *       !equal(nextState, this.state) ||\n     *       !equal(nextContext, this.context);\n     *   }\n     *\n     * @param {object} nextProps\n     * @param {?object} nextState\n     * @param {?object} nextContext\n     * @return {boolean} True if the component should update.\n     * @optional\n     */\n    shouldComponentUpdate: 'DEFINE_ONCE',\n\n    /**\n     * Invoked when the component is about to update due to a transition from\n     * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`\n     * and `nextContext`.\n     *\n     * Use this as an opportunity to perform preparation before an update occurs.\n     *\n     * NOTE: You **cannot** use `this.setState()` in this method.\n     *\n     * @param {object} nextProps\n     * @param {?object} nextState\n     * @param {?object} nextContext\n     * @param {ReactReconcileTransaction} transaction\n     * @optional\n     */\n    componentWillUpdate: 'DEFINE_MANY',\n\n    /**\n     * Invoked when the component's DOM representation has been updated.\n     *\n     * Use this as an opportunity to operate on the DOM when the component has\n     * been updated.\n     *\n     * @param {object} prevProps\n     * @param {?object} prevState\n     * @param {?object} prevContext\n     * @param {DOMElement} rootNode DOM element representing the component.\n     * @optional\n     */\n    componentDidUpdate: 'DEFINE_MANY',\n\n    /**\n     * Invoked when the component is about to be removed from its parent and have\n     * its DOM representation destroyed.\n     *\n     * Use this as an opportunity to deallocate any external resources.\n     *\n     * NOTE: There is no `componentDidUnmount` since your component will have been\n     * destroyed by that point.\n     *\n     * @optional\n     */\n    componentWillUnmount: 'DEFINE_MANY',\n\n    // ==== Advanced methods ====\n\n    /**\n     * Updates the component's currently mounted DOM representation.\n     *\n     * By default, this implements React's rendering and reconciliation algorithm.\n     * Sophisticated clients may wish to override this.\n     *\n     * @param {ReactReconcileTransaction} transaction\n     * @internal\n     * @overridable\n     */\n    updateComponent: 'OVERRIDE_BASE'\n  };\n\n  /**\n   * Mapping from class specification keys to special processing functions.\n   *\n   * Although these are declared like instance properties in the specification\n   * when defining classes using `React.createClass`, they are actually static\n   * and are accessible on the constructor instead of the prototype. Despite\n   * being static, they must be defined outside of the \"statics\" key under\n   * which all other static methods are defined.\n   */\n  var RESERVED_SPEC_KEYS = {\n    displayName: function(Constructor, displayName) {\n      Constructor.displayName = displayName;\n    },\n    mixins: function(Constructor, mixins) {\n      if (mixins) {\n        for (var i = 0; i < mixins.length; i++) {\n          mixSpecIntoComponent(Constructor, mixins[i]);\n        }\n      }\n    },\n    childContextTypes: function(Constructor, childContextTypes) {\n      if (process.env.NODE_ENV !== 'production') {\n        validateTypeDef(Constructor, childContextTypes, 'childContext');\n      }\n      Constructor.childContextTypes = _assign(\n        {},\n        Constructor.childContextTypes,\n        childContextTypes\n      );\n    },\n    contextTypes: function(Constructor, contextTypes) {\n      if (process.env.NODE_ENV !== 'production') {\n        validateTypeDef(Constructor, contextTypes, 'context');\n      }\n      Constructor.contextTypes = _assign(\n        {},\n        Constructor.contextTypes,\n        contextTypes\n      );\n    },\n    /**\n     * Special case getDefaultProps which should move into statics but requires\n     * automatic merging.\n     */\n    getDefaultProps: function(Constructor, getDefaultProps) {\n      if (Constructor.getDefaultProps) {\n        Constructor.getDefaultProps = createMergedResultFunction(\n          Constructor.getDefaultProps,\n          getDefaultProps\n        );\n      } else {\n        Constructor.getDefaultProps = getDefaultProps;\n      }\n    },\n    propTypes: function(Constructor, propTypes) {\n      if (process.env.NODE_ENV !== 'production') {\n        validateTypeDef(Constructor, propTypes, 'prop');\n      }\n      Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);\n    },\n    statics: function(Constructor, statics) {\n      mixStaticSpecIntoComponent(Constructor, statics);\n    },\n    autobind: function() {}\n  };\n\n  function validateTypeDef(Constructor, typeDef, location) {\n    for (var propName in typeDef) {\n      if (typeDef.hasOwnProperty(propName)) {\n        // use a warning instead of an _invariant so components\n        // don't show up in prod but only in __DEV__\n        if (process.env.NODE_ENV !== 'production') {\n          warning(\n            typeof typeDef[propName] === 'function',\n            '%s: %s type `%s` is invalid; it must be a function, usually from ' +\n              'React.PropTypes.',\n            Constructor.displayName || 'ReactClass',\n            ReactPropTypeLocationNames[location],\n            propName\n          );\n        }\n      }\n    }\n  }\n\n  function validateMethodOverride(isAlreadyDefined, name) {\n    var specPolicy = ReactClassInterface.hasOwnProperty(name)\n      ? ReactClassInterface[name]\n      : null;\n\n    // Disallow overriding of base class methods unless explicitly allowed.\n    if (ReactClassMixin.hasOwnProperty(name)) {\n      _invariant(\n        specPolicy === 'OVERRIDE_BASE',\n        'ReactClassInterface: You are attempting to override ' +\n          '`%s` from your class specification. Ensure that your method names ' +\n          'do not overlap with React methods.',\n        name\n      );\n    }\n\n    // Disallow defining methods more than once unless explicitly allowed.\n    if (isAlreadyDefined) {\n      _invariant(\n        specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED',\n        'ReactClassInterface: You are attempting to define ' +\n          '`%s` on your component more than once. This conflict may be due ' +\n          'to a mixin.',\n        name\n      );\n    }\n  }\n\n  /**\n   * Mixin helper which handles policy validation and reserved\n   * specification keys when building React classes.\n   */\n  function mixSpecIntoComponent(Constructor, spec) {\n    if (!spec) {\n      if (process.env.NODE_ENV !== 'production') {\n        var typeofSpec = typeof spec;\n        var isMixinValid = typeofSpec === 'object' && spec !== null;\n\n        if (process.env.NODE_ENV !== 'production') {\n          warning(\n            isMixinValid,\n            \"%s: You're attempting to include a mixin that is either null \" +\n              'or not an object. Check the mixins included by the component, ' +\n              'as well as any mixins they include themselves. ' +\n              'Expected object but got %s.',\n            Constructor.displayName || 'ReactClass',\n            spec === null ? null : typeofSpec\n          );\n        }\n      }\n\n      return;\n    }\n\n    _invariant(\n      typeof spec !== 'function',\n      \"ReactClass: You're attempting to \" +\n        'use a component class or function as a mixin. Instead, just use a ' +\n        'regular object.'\n    );\n    _invariant(\n      !isValidElement(spec),\n      \"ReactClass: You're attempting to \" +\n        'use a component as a mixin. Instead, just use a regular object.'\n    );\n\n    var proto = Constructor.prototype;\n    var autoBindPairs = proto.__reactAutoBindPairs;\n\n    // By handling mixins before any other properties, we ensure the same\n    // chaining order is applied to methods with DEFINE_MANY policy, whether\n    // mixins are listed before or after these methods in the spec.\n    if (spec.hasOwnProperty(MIXINS_KEY)) {\n      RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);\n    }\n\n    for (var name in spec) {\n      if (!spec.hasOwnProperty(name)) {\n        continue;\n      }\n\n      if (name === MIXINS_KEY) {\n        // We have already handled mixins in a special case above.\n        continue;\n      }\n\n      var property = spec[name];\n      var isAlreadyDefined = proto.hasOwnProperty(name);\n      validateMethodOverride(isAlreadyDefined, name);\n\n      if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {\n        RESERVED_SPEC_KEYS[name](Constructor, property);\n      } else {\n        // Setup methods on prototype:\n        // The following member methods should not be automatically bound:\n        // 1. Expected ReactClass methods (in the \"interface\").\n        // 2. Overridden methods (that were mixed in).\n        var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);\n        var isFunction = typeof property === 'function';\n        var shouldAutoBind =\n          isFunction &&\n          !isReactClassMethod &&\n          !isAlreadyDefined &&\n          spec.autobind !== false;\n\n        if (shouldAutoBind) {\n          autoBindPairs.push(name, property);\n          proto[name] = property;\n        } else {\n          if (isAlreadyDefined) {\n            var specPolicy = ReactClassInterface[name];\n\n            // These cases should already be caught by validateMethodOverride.\n            _invariant(\n              isReactClassMethod &&\n                (specPolicy === 'DEFINE_MANY_MERGED' ||\n                  specPolicy === 'DEFINE_MANY'),\n              'ReactClass: Unexpected spec policy %s for key %s ' +\n                'when mixing in component specs.',\n              specPolicy,\n              name\n            );\n\n            // For methods which are defined more than once, call the existing\n            // methods before calling the new property, merging if appropriate.\n            if (specPolicy === 'DEFINE_MANY_MERGED') {\n              proto[name] = createMergedResultFunction(proto[name], property);\n            } else if (specPolicy === 'DEFINE_MANY') {\n              proto[name] = createChainedFunction(proto[name], property);\n            }\n          } else {\n            proto[name] = property;\n            if (process.env.NODE_ENV !== 'production') {\n              // Add verbose displayName to the function, which helps when looking\n              // at profiling tools.\n              if (typeof property === 'function' && spec.displayName) {\n                proto[name].displayName = spec.displayName + '_' + name;\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  function mixStaticSpecIntoComponent(Constructor, statics) {\n    if (!statics) {\n      return;\n    }\n    for (var name in statics) {\n      var property = statics[name];\n      if (!statics.hasOwnProperty(name)) {\n        continue;\n      }\n\n      var isReserved = name in RESERVED_SPEC_KEYS;\n      _invariant(\n        !isReserved,\n        'ReactClass: You are attempting to define a reserved ' +\n          'property, `%s`, that shouldn\\'t be on the \"statics\" key. Define it ' +\n          'as an instance property instead; it will still be accessible on the ' +\n          'constructor.',\n        name\n      );\n\n      var isInherited = name in Constructor;\n      _invariant(\n        !isInherited,\n        'ReactClass: You are attempting to define ' +\n          '`%s` on your component more than once. This conflict may be ' +\n          'due to a mixin.',\n        name\n      );\n      Constructor[name] = property;\n    }\n  }\n\n  /**\n   * Merge two objects, but throw if both contain the same key.\n   *\n   * @param {object} one The first object, which is mutated.\n   * @param {object} two The second object\n   * @return {object} one after it has been mutated to contain everything in two.\n   */\n  function mergeIntoWithNoDuplicateKeys(one, two) {\n    _invariant(\n      one && two && typeof one === 'object' && typeof two === 'object',\n      'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'\n    );\n\n    for (var key in two) {\n      if (two.hasOwnProperty(key)) {\n        _invariant(\n          one[key] === undefined,\n          'mergeIntoWithNoDuplicateKeys(): ' +\n            'Tried to merge two objects with the same key: `%s`. This conflict ' +\n            'may be due to a mixin; in particular, this may be caused by two ' +\n            'getInitialState() or getDefaultProps() methods returning objects ' +\n            'with clashing keys.',\n          key\n        );\n        one[key] = two[key];\n      }\n    }\n    return one;\n  }\n\n  /**\n   * Creates a function that invokes two functions and merges their return values.\n   *\n   * @param {function} one Function to invoke first.\n   * @param {function} two Function to invoke second.\n   * @return {function} Function that invokes the two argument functions.\n   * @private\n   */\n  function createMergedResultFunction(one, two) {\n    return function mergedResult() {\n      var a = one.apply(this, arguments);\n      var b = two.apply(this, arguments);\n      if (a == null) {\n        return b;\n      } else if (b == null) {\n        return a;\n      }\n      var c = {};\n      mergeIntoWithNoDuplicateKeys(c, a);\n      mergeIntoWithNoDuplicateKeys(c, b);\n      return c;\n    };\n  }\n\n  /**\n   * Creates a function that invokes two functions and ignores their return vales.\n   *\n   * @param {function} one Function to invoke first.\n   * @param {function} two Function to invoke second.\n   * @return {function} Function that invokes the two argument functions.\n   * @private\n   */\n  function createChainedFunction(one, two) {\n    return function chainedFunction() {\n      one.apply(this, arguments);\n      two.apply(this, arguments);\n    };\n  }\n\n  /**\n   * Binds a method to the component.\n   *\n   * @param {object} component Component whose method is going to be bound.\n   * @param {function} method Method to be bound.\n   * @return {function} The bound method.\n   */\n  function bindAutoBindMethod(component, method) {\n    var boundMethod = method.bind(component);\n    if (process.env.NODE_ENV !== 'production') {\n      boundMethod.__reactBoundContext = component;\n      boundMethod.__reactBoundMethod = method;\n      boundMethod.__reactBoundArguments = null;\n      var componentName = component.constructor.displayName;\n      var _bind = boundMethod.bind;\n      boundMethod.bind = function(newThis) {\n        for (\n          var _len = arguments.length,\n            args = Array(_len > 1 ? _len - 1 : 0),\n            _key = 1;\n          _key < _len;\n          _key++\n        ) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        // User is trying to bind() an autobound method; we effectively will\n        // ignore the value of \"this\" that the user is trying to use, so\n        // let's warn.\n        if (newThis !== component && newThis !== null) {\n          if (process.env.NODE_ENV !== 'production') {\n            warning(\n              false,\n              'bind(): React component methods may only be bound to the ' +\n                'component instance. See %s',\n              componentName\n            );\n          }\n        } else if (!args.length) {\n          if (process.env.NODE_ENV !== 'production') {\n            warning(\n              false,\n              'bind(): You are binding a component method to the component. ' +\n                'React does this for you automatically in a high-performance ' +\n                'way, so you can safely remove this call. See %s',\n              componentName\n            );\n          }\n          return boundMethod;\n        }\n        var reboundMethod = _bind.apply(boundMethod, arguments);\n        reboundMethod.__reactBoundContext = component;\n        reboundMethod.__reactBoundMethod = method;\n        reboundMethod.__reactBoundArguments = args;\n        return reboundMethod;\n      };\n    }\n    return boundMethod;\n  }\n\n  /**\n   * Binds all auto-bound methods in a component.\n   *\n   * @param {object} component Component whose method is going to be bound.\n   */\n  function bindAutoBindMethods(component) {\n    var pairs = component.__reactAutoBindPairs;\n    for (var i = 0; i < pairs.length; i += 2) {\n      var autoBindKey = pairs[i];\n      var method = pairs[i + 1];\n      component[autoBindKey] = bindAutoBindMethod(component, method);\n    }\n  }\n\n  var IsMountedPreMixin = {\n    componentDidMount: function() {\n      this.__isMounted = true;\n    }\n  };\n\n  var IsMountedPostMixin = {\n    componentWillUnmount: function() {\n      this.__isMounted = false;\n    }\n  };\n\n  /**\n   * Add more to the ReactClass base class. These are all legacy features and\n   * therefore not already part of the modern ReactComponent.\n   */\n  var ReactClassMixin = {\n    /**\n     * TODO: This will be deprecated because state should always keep a consistent\n     * type signature and the only use case for this, is to avoid that.\n     */\n    replaceState: function(newState, callback) {\n      this.updater.enqueueReplaceState(this, newState, callback);\n    },\n\n    /**\n     * Checks whether or not this composite component is mounted.\n     * @return {boolean} True if mounted, false otherwise.\n     * @protected\n     * @final\n     */\n    isMounted: function() {\n      if (process.env.NODE_ENV !== 'production') {\n        warning(\n          this.__didWarnIsMounted,\n          '%s: isMounted is deprecated. Instead, make sure to clean up ' +\n            'subscriptions and pending requests in componentWillUnmount to ' +\n            'prevent memory leaks.',\n          (this.constructor && this.constructor.displayName) ||\n            this.name ||\n            'Component'\n        );\n        this.__didWarnIsMounted = true;\n      }\n      return !!this.__isMounted;\n    }\n  };\n\n  var ReactClassComponent = function() {};\n  _assign(\n    ReactClassComponent.prototype,\n    ReactComponent.prototype,\n    ReactClassMixin\n  );\n\n  /**\n   * Creates a composite component class given a class specification.\n   * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass\n   *\n   * @param {object} spec Class specification (which must define `render`).\n   * @return {function} Component constructor function.\n   * @public\n   */\n  function createClass(spec) {\n    // To keep our warnings more understandable, we'll use a little hack here to\n    // ensure that Constructor.name !== 'Constructor'. This makes sure we don't\n    // unnecessarily identify a class without displayName as 'Constructor'.\n    var Constructor = identity(function(props, context, updater) {\n      // This constructor gets overridden by mocks. The argument is used\n      // by mocks to assert on what gets mounted.\n\n      if (process.env.NODE_ENV !== 'production') {\n        warning(\n          this instanceof Constructor,\n          'Something is calling a React component directly. Use a factory or ' +\n            'JSX instead. See: https://fb.me/react-legacyfactory'\n        );\n      }\n\n      // Wire up auto-binding\n      if (this.__reactAutoBindPairs.length) {\n        bindAutoBindMethods(this);\n      }\n\n      this.props = props;\n      this.context = context;\n      this.refs = emptyObject;\n      this.updater = updater || ReactNoopUpdateQueue;\n\n      this.state = null;\n\n      // ReactClasses doesn't have constructors. Instead, they use the\n      // getInitialState and componentWillMount methods for initialization.\n\n      var initialState = this.getInitialState ? this.getInitialState() : null;\n      if (process.env.NODE_ENV !== 'production') {\n        // We allow auto-mocks to proceed as if they're returning null.\n        if (\n          initialState === undefined &&\n          this.getInitialState._isMockFunction\n        ) {\n          // This is probably bad practice. Consider warning here and\n          // deprecating this convenience.\n          initialState = null;\n        }\n      }\n      _invariant(\n        typeof initialState === 'object' && !Array.isArray(initialState),\n        '%s.getInitialState(): must return an object or null',\n        Constructor.displayName || 'ReactCompositeComponent'\n      );\n\n      this.state = initialState;\n    });\n    Constructor.prototype = new ReactClassComponent();\n    Constructor.prototype.constructor = Constructor;\n    Constructor.prototype.__reactAutoBindPairs = [];\n\n    injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));\n\n    mixSpecIntoComponent(Constructor, IsMountedPreMixin);\n    mixSpecIntoComponent(Constructor, spec);\n    mixSpecIntoComponent(Constructor, IsMountedPostMixin);\n\n    // Initialize the defaultProps property after all mixins have been merged.\n    if (Constructor.getDefaultProps) {\n      Constructor.defaultProps = Constructor.getDefaultProps();\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      // This is a tag to indicate that the use of these method names is ok,\n      // since it's used with createClass. If it's not, then it's likely a\n      // mistake so we'll warn you to use the static property, property\n      // initializer or constructor respectively.\n      if (Constructor.getDefaultProps) {\n        Constructor.getDefaultProps.isReactClassApproved = {};\n      }\n      if (Constructor.prototype.getInitialState) {\n        Constructor.prototype.getInitialState.isReactClassApproved = {};\n      }\n    }\n\n    _invariant(\n      Constructor.prototype.render,\n      'createClass(...): Class specification must implement a `render` method.'\n    );\n\n    if (process.env.NODE_ENV !== 'production') {\n      warning(\n        !Constructor.prototype.componentShouldUpdate,\n        '%s has a method called ' +\n          'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +\n          'The name is phrased as a question because the function is ' +\n          'expected to return a value.',\n        spec.displayName || 'A component'\n      );\n      warning(\n        !Constructor.prototype.componentWillRecieveProps,\n        '%s has a method called ' +\n          'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?',\n        spec.displayName || 'A component'\n      );\n    }\n\n    // Reduce time spent doing lookups by setting these on the prototype.\n    for (var methodName in ReactClassInterface) {\n      if (!Constructor.prototype[methodName]) {\n        Constructor.prototype[methodName] = null;\n      }\n    }\n\n    return Constructor;\n  }\n\n  return createClass;\n}\n\nmodule.exports = factory;\n"]}