Created
March 3, 2017 14:14
-
-
Save trueadm/06e7b005c80a4370757fcee9dd4d1718 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /** | |
| * React v16.0.0-alpha.3 | |
| * | |
| * Copyright 2013-present, Facebook, Inc. | |
| * All rights reserved. | |
| * | |
| * This source code is licensed under the BSD-style license found in the | |
| * LICENSE file in the root directory of this source tree. An additional grant | |
| * of patent rights can be found in the PATENTS file in the same directory. | |
| * | |
| */ | |
| !function(f) { | |
| if ("object" == typeof exports && "undefined" != typeof module) module.exports = f(); else if ("function" == typeof define && define.amd) define([], f); else { | |
| var g; | |
| g = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : this, | |
| g.React = f(); | |
| } | |
| }(function() { | |
| return function e(t, n, r) { | |
| function s(o, u) { | |
| if (!n[o]) { | |
| if (!t[o]) { | |
| var a = "function" == typeof require && 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; | |
| } | |
| for (var i = "function" == typeof require && require, o = 0; o < r.length; o++) s(r[o]); | |
| return s; | |
| }({ | |
| 1: [ function(require, module, exports) { | |
| "use strict"; | |
| function escape(e) { | |
| var n = { | |
| "=": "=0", | |
| ":": "=2" | |
| }; | |
| return "$" + ("" + e).replace(/[=:]/g, function(e) { | |
| return n[e]; | |
| }); | |
| } | |
| function unescape(e) { | |
| var n = { | |
| "=0": "=", | |
| "=2": ":" | |
| }; | |
| return ("" + ("." === e[0] && "$" === e[1] ? e.substring(2) : e.substring(1))).replace(/(=0|=2)/g, function(e) { | |
| return n[e]; | |
| }); | |
| } | |
| var KeyEscapeUtils = { | |
| escape: escape, | |
| unescape: unescape | |
| }; | |
| module.exports = KeyEscapeUtils; | |
| }, {} ], | |
| 2: [ function(require, module, exports) { | |
| "use strict"; | |
| var _prodInvariant = require(23), oneArgumentPooler = (require(27), function(o) { | |
| var e = this; | |
| if (e.instancePool.length) { | |
| var n = e.instancePool.pop(); | |
| return e.call(n, o), n; | |
| } | |
| return new e(o); | |
| }), twoArgumentPooler = function(o, e) { | |
| var n = this; | |
| if (n.instancePool.length) { | |
| var r = n.instancePool.pop(); | |
| return n.call(r, o, e), r; | |
| } | |
| return new n(o, e); | |
| }, threeArgumentPooler = function(o, e, n) { | |
| var r = this; | |
| if (r.instancePool.length) { | |
| var t = r.instancePool.pop(); | |
| return r.call(t, o, e, n), t; | |
| } | |
| return new r(o, e, n); | |
| }, fourArgumentPooler = function(o, e, n, r) { | |
| var t = this; | |
| if (t.instancePool.length) { | |
| var l = t.instancePool.pop(); | |
| return t.call(l, o, e, n, r), l; | |
| } | |
| return new t(o, e, n, r); | |
| }, standardReleaser = function(o) { | |
| var e = this; | |
| o instanceof e || _prodInvariant("25"), o.destructor(), e.instancePool.length < e.poolSize && e.instancePool.push(o); | |
| }, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(o, e) { | |
| var n = o; | |
| return n.instancePool = [], n.getPooled = e || DEFAULT_POOLER, n.poolSize || (n.poolSize = 10), | |
| n.release = standardReleaser, n; | |
| }, PooledClass = { | |
| addPoolingTo: addPoolingTo, | |
| oneArgumentPooler: oneArgumentPooler, | |
| twoArgumentPooler: twoArgumentPooler, | |
| threeArgumentPooler: threeArgumentPooler, | |
| fourArgumentPooler: fourArgumentPooler | |
| }; | |
| module.exports = PooledClass; | |
| }, { | |
| "23": 23, | |
| "27": 27 | |
| } ], | |
| 3: [ function(require, module, exports) { | |
| "use strict"; | |
| var ReactBaseClasses = require(4), ReactChildren = require(5), ReactClass = require(6), ReactDOMFactories = require(9), ReactElement = require(10), ReactPropTypes = require(13), ReactVersion = require(17), onlyChild = require(22), checkPropTypes = (require(28), | |
| require(19)), createElement = ReactElement.createElement, createFactory = ReactElement.createFactory, cloneElement = ReactElement.cloneElement, createMixin = function(e) { | |
| return e; | |
| }, React = { | |
| Children: { | |
| map: ReactChildren.map, | |
| forEach: ReactChildren.forEach, | |
| count: ReactChildren.count, | |
| toArray: ReactChildren.toArray, | |
| only: onlyChild | |
| }, | |
| Component: ReactBaseClasses.Component, | |
| PureComponent: ReactBaseClasses.PureComponent, | |
| createElement: createElement, | |
| cloneElement: cloneElement, | |
| isValidElement: ReactElement.isValidElement, | |
| checkPropTypes: checkPropTypes, | |
| PropTypes: ReactPropTypes, | |
| createClass: ReactClass.createClass, | |
| createFactory: createFactory, | |
| createMixin: createMixin, | |
| DOM: ReactDOMFactories, | |
| version: ReactVersion | |
| }; | |
| module.exports = React; | |
| }, { | |
| "10": 10, | |
| "13": 13, | |
| "17": 17, | |
| "19": 19, | |
| "22": 22, | |
| "28": 28, | |
| "4": 4, | |
| "5": 5, | |
| "6": 6, | |
| "9": 9 | |
| } ], | |
| 4: [ function(require, module, exports) { | |
| "use strict"; | |
| function ReactComponent(e, t, o) { | |
| this.props = e, this.context = t, this.refs = emptyObject, this.updater = o || ReactNoopUpdateQueue; | |
| } | |
| function ReactPureComponent(e, t, o) { | |
| this.props = e, this.context = t, this.refs = emptyObject, this.updater = o || ReactNoopUpdateQueue; | |
| } | |
| function ComponentDummy() {} | |
| var _prodInvariant = require(23), _assign = require(29), ReactNoopUpdateQueue = require(12), emptyObject = (require(18), | |
| require(26)); | |
| require(27), require(28); | |
| ReactComponent.prototype.isReactComponent = {}, ReactComponent.prototype.setState = function(e, t) { | |
| "object" != typeof e && "function" != typeof e && null != e && _prodInvariant("85"), | |
| this.updater.enqueueSetState(this, e, t, "setState"); | |
| }, ReactComponent.prototype.forceUpdate = function(e) { | |
| this.updater.enqueueForceUpdate(this, e, "forceUpdate"); | |
| }; | |
| ComponentDummy.prototype = ReactComponent.prototype, ReactPureComponent.prototype = new ComponentDummy(), | |
| ReactPureComponent.prototype.constructor = ReactPureComponent, _assign(ReactPureComponent.prototype, ReactComponent.prototype), | |
| ReactPureComponent.prototype.isPureReactComponent = !0, module.exports = { | |
| Component: ReactComponent, | |
| PureComponent: ReactPureComponent | |
| }; | |
| }, { | |
| "12": 12, | |
| "18": 18, | |
| "23": 23, | |
| "26": 26, | |
| "27": 27, | |
| "28": 28, | |
| "29": 29 | |
| } ], | |
| 5: [ function(require, module, exports) { | |
| "use strict"; | |
| function escapeUserProvidedKey(e) { | |
| return ("" + e).replace(/\/+/g, "$&/"); | |
| } | |
| function ForEachBookKeeping(e, n) { | |
| this.func = e, this.context = n, this.count = 0; | |
| } | |
| function forEachSingleChild(e, n, t) { | |
| var r = e.func, o = e.context; | |
| r.call(o, n, e.count++); | |
| } | |
| function forEachChildren(e, n, t) { | |
| if (null == e) return e; | |
| var r = ForEachBookKeeping.getPooled(n, t); | |
| traverseAllChildren(e, forEachSingleChild, r), ForEachBookKeeping.release(r); | |
| } | |
| function MapBookKeeping(e, n, t, r) { | |
| this.result = e, this.keyPrefix = n, this.func = t, this.context = r, this.count = 0; | |
| } | |
| function mapSingleChildIntoContext(e, n, t) { | |
| var r = e.result, o = e.keyPrefix, l = e.func, i = e.context, u = l.call(i, n, e.count++); | |
| Array.isArray(u) ? mapIntoWithKeyPrefixInternal(u, r, t, emptyFunction.thatReturnsArgument) : null != u && (ReactElement.isValidElement(u) && (u = ReactElement.cloneAndReplaceKey(u, o + (!u.key || n && n.key === u.key ? "" : escapeUserProvidedKey(u.key) + "/") + t)), | |
| r.push(u)); | |
| } | |
| function mapIntoWithKeyPrefixInternal(e, n, t, r, o) { | |
| var l = ""; | |
| null != t && (l = escapeUserProvidedKey(t) + "/"); | |
| var i = MapBookKeeping.getPooled(n, l, r, o); | |
| traverseAllChildren(e, mapSingleChildIntoContext, i), MapBookKeeping.release(i); | |
| } | |
| function mapChildren(e, n, t) { | |
| if (null == e) return e; | |
| var r = []; | |
| return mapIntoWithKeyPrefixInternal(e, r, null, n, t), r; | |
| } | |
| function forEachSingleChildDummy(e, n, t) { | |
| return null; | |
| } | |
| function countChildren(e, n) { | |
| return traverseAllChildren(e, forEachSingleChildDummy, null); | |
| } | |
| function toArray(e) { | |
| var n = []; | |
| return mapIntoWithKeyPrefixInternal(e, n, null, emptyFunction.thatReturnsArgument), | |
| n; | |
| } | |
| var PooledClass = require(2), ReactElement = require(10), emptyFunction = require(25), traverseAllChildren = require(24), twoArgumentPooler = PooledClass.twoArgumentPooler, fourArgumentPooler = PooledClass.fourArgumentPooler; | |
| ForEachBookKeeping.prototype.destructor = function() { | |
| this.func = null, this.context = null, this.count = 0; | |
| }, PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler), MapBookKeeping.prototype.destructor = function() { | |
| this.result = null, this.keyPrefix = null, this.func = null, this.context = null, | |
| this.count = 0; | |
| }, PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler); | |
| var ReactChildren = { | |
| forEach: forEachChildren, | |
| map: mapChildren, | |
| mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal, | |
| count: countChildren, | |
| toArray: toArray | |
| }; | |
| module.exports = ReactChildren; | |
| }, { | |
| "10": 10, | |
| "2": 2, | |
| "24": 24, | |
| "25": 25 | |
| } ], | |
| 6: [ function(require, module, exports) { | |
| "use strict"; | |
| function identity(t) { | |
| return t; | |
| } | |
| function validateMethodOverride(t, e) { | |
| var n = ReactClassInterface.hasOwnProperty(e) ? ReactClassInterface[e] : null; | |
| ReactClassMixin.hasOwnProperty(e) && "OVERRIDE_BASE" !== n && _prodInvariant("73", e), | |
| t && "DEFINE_MANY" !== n && "DEFINE_MANY_MERGED" !== n && _prodInvariant("74", e); | |
| } | |
| function mixSpecIntoComponent(t, e) { | |
| if (e) { | |
| "function" == typeof e && _prodInvariant("75"), ReactElement.isValidElement(e) && _prodInvariant("76"); | |
| var n = t.prototype, a = n.__reactAutoBindPairs; | |
| e.hasOwnProperty("mixins") && RESERVED_SPEC_KEYS.mixins(t, e.mixins); | |
| for (var o in e) if (e.hasOwnProperty(o) && "mixins" !== o) { | |
| var i = e[o], r = n.hasOwnProperty(o); | |
| if (validateMethodOverride(r, o), RESERVED_SPEC_KEYS.hasOwnProperty(o)) RESERVED_SPEC_KEYS[o](t, i); else { | |
| var s = ReactClassInterface.hasOwnProperty(o), p = "function" == typeof i, c = p && !s && !r && e.autobind !== !1; | |
| if (c) a.push(o, i), n[o] = i; else if (r) { | |
| var u = ReactClassInterface[o]; | |
| (!s || "DEFINE_MANY_MERGED" !== u && "DEFINE_MANY" !== u) && _prodInvariant("77", u, o), | |
| "DEFINE_MANY_MERGED" === u ? n[o] = createMergedResultFunction(n[o], i) : "DEFINE_MANY" === u && (n[o] = createChainedFunction(n[o], i)); | |
| } else n[o] = i; | |
| } | |
| } | |
| } | |
| } | |
| function mixStaticSpecIntoComponent(t, e) { | |
| if (e) for (var n in e) { | |
| var a = e[n]; | |
| if (e.hasOwnProperty(n)) { | |
| var o = n in RESERVED_SPEC_KEYS; | |
| o && _prodInvariant("78", n); | |
| var i = n in t; | |
| i && _prodInvariant("79", n), t[n] = a; | |
| } | |
| } | |
| } | |
| function mergeIntoWithNoDuplicateKeys(t, e) { | |
| t && e && "object" == typeof t && "object" == typeof e || _prodInvariant("80"); | |
| for (var n in e) e.hasOwnProperty(n) && (void 0 !== t[n] && _prodInvariant("81", n), | |
| t[n] = e[n]); | |
| return t; | |
| } | |
| function createMergedResultFunction(t, e) { | |
| return function() { | |
| var n = t.apply(this, arguments), a = e.apply(this, arguments); | |
| if (null == n) return a; | |
| if (null == a) return n; | |
| var o = {}; | |
| return mergeIntoWithNoDuplicateKeys(o, n), mergeIntoWithNoDuplicateKeys(o, a), o; | |
| }; | |
| } | |
| function createChainedFunction(t, e) { | |
| return function() { | |
| t.apply(this, arguments), e.apply(this, arguments); | |
| }; | |
| } | |
| function bindAutoBindMethod(t, e) { | |
| return e.bind(t); | |
| } | |
| function bindAutoBindMethods(t) { | |
| for (var e = t.__reactAutoBindPairs, n = 0; n < e.length; n += 2) { | |
| var a = e[n], o = e[n + 1]; | |
| t[a] = bindAutoBindMethod(t, o); | |
| } | |
| } | |
| var _assign = require(29), _prodInvariant = require(23), ReactBaseClasses = require(4), ReactElement = require(10), ReactNoopUpdateQueue = require(12), emptyObject = require(26), ReactComponent = (require(27), | |
| require(28), ReactBaseClasses.Component), ReactClassInterface = { | |
| mixins: "DEFINE_MANY", | |
| statics: "DEFINE_MANY", | |
| propTypes: "DEFINE_MANY", | |
| contextTypes: "DEFINE_MANY", | |
| childContextTypes: "DEFINE_MANY", | |
| getDefaultProps: "DEFINE_MANY_MERGED", | |
| getInitialState: "DEFINE_MANY_MERGED", | |
| getChildContext: "DEFINE_MANY_MERGED", | |
| render: "DEFINE_ONCE", | |
| componentWillMount: "DEFINE_MANY", | |
| componentDidMount: "DEFINE_MANY", | |
| componentWillReceiveProps: "DEFINE_MANY", | |
| shouldComponentUpdate: "DEFINE_ONCE", | |
| componentWillUpdate: "DEFINE_MANY", | |
| componentDidUpdate: "DEFINE_MANY", | |
| componentWillUnmount: "DEFINE_MANY", | |
| updateComponent: "OVERRIDE_BASE" | |
| }, RESERVED_SPEC_KEYS = { | |
| displayName: function(t, e) { | |
| t.displayName = e; | |
| }, | |
| mixins: function(t, e) { | |
| if (e) for (var n = 0; n < e.length; n++) mixSpecIntoComponent(t, e[n]); | |
| }, | |
| childContextTypes: function(t, e) { | |
| t.childContextTypes = _assign({}, t.childContextTypes, e); | |
| }, | |
| contextTypes: function(t, e) { | |
| t.contextTypes = _assign({}, t.contextTypes, e); | |
| }, | |
| getDefaultProps: function(t, e) { | |
| t.getDefaultProps ? t.getDefaultProps = createMergedResultFunction(t.getDefaultProps, e) : t.getDefaultProps = e; | |
| }, | |
| propTypes: function(t, e) { | |
| t.propTypes = _assign({}, t.propTypes, e); | |
| }, | |
| statics: function(t, e) { | |
| mixStaticSpecIntoComponent(t, e); | |
| }, | |
| autobind: function() {} | |
| }, ReactClassMixin = { | |
| replaceState: function(t, e) { | |
| this.updater.enqueueReplaceState(this, t, e, "replaceState"); | |
| }, | |
| isMounted: function() { | |
| return this.updater.isMounted(this); | |
| } | |
| }, ReactClassComponent = function() {}; | |
| _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin); | |
| var ReactClass = { | |
| createClass: function(t) { | |
| var e = identity(function(t, n, a) { | |
| this.__reactAutoBindPairs.length && bindAutoBindMethods(this), this.props = t, this.context = n, | |
| this.refs = emptyObject, this.updater = a || ReactNoopUpdateQueue, this.state = null; | |
| var o = this.getInitialState ? this.getInitialState() : null; | |
| ("object" != typeof o || Array.isArray(o)) && _prodInvariant("82", e.displayName || "ReactCompositeComponent"), | |
| this.state = o; | |
| }); | |
| e.prototype = new ReactClassComponent(), e.prototype.constructor = e, e.prototype.__reactAutoBindPairs = [], | |
| mixSpecIntoComponent(e, t), e.getDefaultProps && (e.defaultProps = e.getDefaultProps()), | |
| e.prototype.render || _prodInvariant("83"); | |
| for (var n in ReactClassInterface) e.prototype[n] || (e.prototype[n] = null); | |
| return e; | |
| } | |
| }; | |
| module.exports = ReactClass; | |
| }, { | |
| "10": 10, | |
| "12": 12, | |
| "23": 23, | |
| "26": 26, | |
| "27": 27, | |
| "28": 28, | |
| "29": 29, | |
| "4": 4 | |
| } ], | |
| 7: [ function(require, module, exports) { | |
| "use strict"; | |
| function describeComponentFrame(e, t, n) { | |
| return "\n in " + (e || "Unknown") + (t ? " (at " + t.fileName.replace(/^.*[\\\/]/, "") + ":" + t.lineNumber + ")" : n ? " (created by " + n + ")" : ""); | |
| } | |
| function describeFiber(e) { | |
| switch (e.tag) { | |
| case IndeterminateComponent: | |
| case FunctionalComponent: | |
| case ClassComponent: | |
| case HostComponent: | |
| var t = e._debugOwner, n = e._debugSource, o = getComponentName(e), r = null; | |
| return t && (r = getComponentName(t)), describeComponentFrame(o, n, r); | |
| default: | |
| return ""; | |
| } | |
| } | |
| var getComponentName = (require(29), require(23), require(20)), ReactTypeOfWork = require(15), IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent = ReactTypeOfWork.FunctionalComponent, ClassComponent = ReactTypeOfWork.ClassComponent, HostComponent = ReactTypeOfWork.HostComponent, ReactComponentTreeHook = { | |
| getStackAddendumByWorkInProgressFiber: function(e) { | |
| var t = "", n = e; | |
| do t += describeFiber(n), n = n.return; while (n); | |
| return t; | |
| } | |
| }; | |
| module.exports = ReactComponentTreeHook; | |
| }, { | |
| "15": 15, | |
| "20": 20, | |
| "23": 23, | |
| "29": 29 | |
| } ], | |
| 8: [ function(require, module, exports) { | |
| "use strict"; | |
| var ReactCurrentOwner = { | |
| current: null | |
| }; | |
| module.exports = ReactCurrentOwner; | |
| }, {} ], | |
| 9: [ function(require, module, exports) { | |
| "use strict"; | |
| var ReactElement = require(10), createDOMFactory = ReactElement.createFactory, ReactDOMFactories = { | |
| a: createDOMFactory("a"), | |
| abbr: createDOMFactory("abbr"), | |
| address: createDOMFactory("address"), | |
| area: createDOMFactory("area"), | |
| article: createDOMFactory("article"), | |
| aside: createDOMFactory("aside"), | |
| audio: createDOMFactory("audio"), | |
| b: createDOMFactory("b"), | |
| base: createDOMFactory("base"), | |
| bdi: createDOMFactory("bdi"), | |
| bdo: createDOMFactory("bdo"), | |
| big: createDOMFactory("big"), | |
| blockquote: createDOMFactory("blockquote"), | |
| body: createDOMFactory("body"), | |
| br: createDOMFactory("br"), | |
| button: createDOMFactory("button"), | |
| canvas: createDOMFactory("canvas"), | |
| caption: createDOMFactory("caption"), | |
| cite: createDOMFactory("cite"), | |
| code: createDOMFactory("code"), | |
| col: createDOMFactory("col"), | |
| colgroup: createDOMFactory("colgroup"), | |
| data: createDOMFactory("data"), | |
| datalist: createDOMFactory("datalist"), | |
| dd: createDOMFactory("dd"), | |
| del: createDOMFactory("del"), | |
| details: createDOMFactory("details"), | |
| dfn: createDOMFactory("dfn"), | |
| dialog: createDOMFactory("dialog"), | |
| div: createDOMFactory("div"), | |
| dl: createDOMFactory("dl"), | |
| dt: createDOMFactory("dt"), | |
| em: createDOMFactory("em"), | |
| embed: createDOMFactory("embed"), | |
| fieldset: createDOMFactory("fieldset"), | |
| figcaption: createDOMFactory("figcaption"), | |
| figure: createDOMFactory("figure"), | |
| footer: createDOMFactory("footer"), | |
| form: createDOMFactory("form"), | |
| h1: createDOMFactory("h1"), | |
| h2: createDOMFactory("h2"), | |
| h3: createDOMFactory("h3"), | |
| h4: createDOMFactory("h4"), | |
| h5: createDOMFactory("h5"), | |
| h6: createDOMFactory("h6"), | |
| head: createDOMFactory("head"), | |
| header: createDOMFactory("header"), | |
| hgroup: createDOMFactory("hgroup"), | |
| hr: createDOMFactory("hr"), | |
| html: createDOMFactory("html"), | |
| i: createDOMFactory("i"), | |
| iframe: createDOMFactory("iframe"), | |
| img: createDOMFactory("img"), | |
| input: createDOMFactory("input"), | |
| ins: createDOMFactory("ins"), | |
| kbd: createDOMFactory("kbd"), | |
| keygen: createDOMFactory("keygen"), | |
| label: createDOMFactory("label"), | |
| legend: createDOMFactory("legend"), | |
| li: createDOMFactory("li"), | |
| link: createDOMFactory("link"), | |
| main: createDOMFactory("main"), | |
| map: createDOMFactory("map"), | |
| mark: createDOMFactory("mark"), | |
| menu: createDOMFactory("menu"), | |
| menuitem: createDOMFactory("menuitem"), | |
| meta: createDOMFactory("meta"), | |
| meter: createDOMFactory("meter"), | |
| nav: createDOMFactory("nav"), | |
| noscript: createDOMFactory("noscript"), | |
| object: createDOMFactory("object"), | |
| ol: createDOMFactory("ol"), | |
| optgroup: createDOMFactory("optgroup"), | |
| option: createDOMFactory("option"), | |
| output: createDOMFactory("output"), | |
| p: createDOMFactory("p"), | |
| param: createDOMFactory("param"), | |
| picture: createDOMFactory("picture"), | |
| pre: createDOMFactory("pre"), | |
| progress: createDOMFactory("progress"), | |
| q: createDOMFactory("q"), | |
| rp: createDOMFactory("rp"), | |
| rt: createDOMFactory("rt"), | |
| ruby: createDOMFactory("ruby"), | |
| s: createDOMFactory("s"), | |
| samp: createDOMFactory("samp"), | |
| script: createDOMFactory("script"), | |
| section: createDOMFactory("section"), | |
| select: createDOMFactory("select"), | |
| small: createDOMFactory("small"), | |
| source: createDOMFactory("source"), | |
| span: createDOMFactory("span"), | |
| strong: createDOMFactory("strong"), | |
| style: createDOMFactory("style"), | |
| sub: createDOMFactory("sub"), | |
| summary: createDOMFactory("summary"), | |
| sup: createDOMFactory("sup"), | |
| table: createDOMFactory("table"), | |
| tbody: createDOMFactory("tbody"), | |
| td: createDOMFactory("td"), | |
| textarea: createDOMFactory("textarea"), | |
| tfoot: createDOMFactory("tfoot"), | |
| th: createDOMFactory("th"), | |
| thead: createDOMFactory("thead"), | |
| time: createDOMFactory("time"), | |
| title: createDOMFactory("title"), | |
| tr: createDOMFactory("tr"), | |
| track: createDOMFactory("track"), | |
| u: createDOMFactory("u"), | |
| ul: createDOMFactory("ul"), | |
| var: createDOMFactory("var"), | |
| video: createDOMFactory("video"), | |
| wbr: createDOMFactory("wbr"), | |
| circle: createDOMFactory("circle"), | |
| clipPath: createDOMFactory("clipPath"), | |
| defs: createDOMFactory("defs"), | |
| ellipse: createDOMFactory("ellipse"), | |
| g: createDOMFactory("g"), | |
| image: createDOMFactory("image"), | |
| line: createDOMFactory("line"), | |
| linearGradient: createDOMFactory("linearGradient"), | |
| mask: createDOMFactory("mask"), | |
| path: createDOMFactory("path"), | |
| pattern: createDOMFactory("pattern"), | |
| polygon: createDOMFactory("polygon"), | |
| polyline: createDOMFactory("polyline"), | |
| radialGradient: createDOMFactory("radialGradient"), | |
| rect: createDOMFactory("rect"), | |
| stop: createDOMFactory("stop"), | |
| svg: createDOMFactory("svg"), | |
| text: createDOMFactory("text"), | |
| tspan: createDOMFactory("tspan") | |
| }; | |
| module.exports = ReactDOMFactories; | |
| }, { | |
| "10": 10 | |
| } ], | |
| 10: [ function(require, module, exports) { | |
| "use strict"; | |
| function hasValidRef(e) { | |
| return void 0 !== e.ref; | |
| } | |
| function hasValidKey(e) { | |
| return void 0 !== e.key; | |
| } | |
| var _assign = require(29), ReactCurrentOwner = require(8), hasOwnProperty = (require(28), | |
| require(18), Object.prototype.hasOwnProperty), REACT_ELEMENT_TYPE = require(11), RESERVED_PROPS = { | |
| key: !0, | |
| ref: !0, | |
| __self: !0, | |
| __source: !0 | |
| }, ReactElement = function(e, r, n, t, a, i, l) { | |
| return { | |
| $$typeof: REACT_ELEMENT_TYPE, | |
| type: e, | |
| key: r, | |
| ref: n, | |
| props: l, | |
| _owner: i | |
| }; | |
| }; | |
| ReactElement.createElement = function(e, r, n) { | |
| var t, a = {}, i = null, l = null, o = null, c = null; | |
| if (null != r) { | |
| hasValidRef(r) && (l = r.ref), hasValidKey(r) && (i = "" + r.key), o = void 0 === r.__self ? null : r.__self, | |
| c = void 0 === r.__source ? null : r.__source; | |
| for (t in r) hasOwnProperty.call(r, t) && !RESERVED_PROPS.hasOwnProperty(t) && (a[t] = r[t]); | |
| } | |
| var f = arguments.length - 2; | |
| if (1 === f) a.children = n; else if (f > 1) { | |
| for (var u = Array(f), s = 0; s < f; s++) u[s] = arguments[s + 2]; | |
| a.children = u; | |
| } | |
| if (e && e.defaultProps) { | |
| var p = e.defaultProps; | |
| for (t in p) void 0 === a[t] && (a[t] = p[t]); | |
| } | |
| return ReactElement(e, i, l, o, c, ReactCurrentOwner.current, a); | |
| }, ReactElement.createFactory = function(e) { | |
| var r = ReactElement.createElement.bind(null, e); | |
| return r.type = e, r; | |
| }, ReactElement.cloneAndReplaceKey = function(e, r) { | |
| return ReactElement(e.type, r, e.ref, e._self, e._source, e._owner, e.props); | |
| }, ReactElement.cloneElement = function(e, r, n) { | |
| var t, a = _assign({}, e.props), i = e.key, l = e.ref, o = e._self, c = e._source, f = e._owner; | |
| if (null != r) { | |
| hasValidRef(r) && (l = r.ref, f = ReactCurrentOwner.current), hasValidKey(r) && (i = "" + r.key); | |
| var u; | |
| e.type && e.type.defaultProps && (u = e.type.defaultProps); | |
| for (t in r) hasOwnProperty.call(r, t) && !RESERVED_PROPS.hasOwnProperty(t) && (void 0 === r[t] && void 0 !== u ? a[t] = u[t] : a[t] = r[t]); | |
| } | |
| var s = arguments.length - 2; | |
| if (1 === s) a.children = n; else if (s > 1) { | |
| for (var p = Array(s), y = 0; y < s; y++) p[y] = arguments[y + 2]; | |
| a.children = p; | |
| } | |
| return ReactElement(e.type, i, l, o, c, f, a); | |
| }, ReactElement.isValidElement = function(e) { | |
| return "object" == typeof e && null !== e && e.$$typeof === REACT_ELEMENT_TYPE; | |
| }, module.exports = ReactElement; | |
| }, { | |
| "11": 11, | |
| "18": 18, | |
| "28": 28, | |
| "29": 29, | |
| "8": 8 | |
| } ], | |
| 11: [ function(require, module, exports) { | |
| "use strict"; | |
| var REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103; | |
| module.exports = REACT_ELEMENT_TYPE; | |
| }, {} ], | |
| 12: [ function(require, module, exports) { | |
| "use strict"; | |
| function warnNoop(e, t) {} | |
| var ReactNoopUpdateQueue = (require(28), { | |
| isMounted: function(e) { | |
| return !1; | |
| }, | |
| enqueueForceUpdate: function(e, t, n) { | |
| warnNoop(e, "forceUpdate"); | |
| }, | |
| enqueueReplaceState: function(e, t, n, o) { | |
| warnNoop(e, "replaceState"); | |
| }, | |
| enqueueSetState: function(e, t, n, o) { | |
| warnNoop(e, "setState"); | |
| } | |
| }); | |
| module.exports = ReactNoopUpdateQueue; | |
| }, { | |
| "28": 28 | |
| } ], | |
| 13: [ function(require, module, exports) { | |
| "use strict"; | |
| function PropTypeError(e) { | |
| this.message = e, this.stack = ""; | |
| } | |
| var ReactPropTypes, invariant = (require(10), require(14), require(25), require(21), | |
| require(27)), productionTypeChecker = (require(28), function() { | |
| invariant(!1, "React.PropTypes type checking code is stripped in production."); | |
| }); | |
| productionTypeChecker.isRequired = productionTypeChecker; | |
| var getProductionTypeChecker = function() { | |
| return productionTypeChecker; | |
| }; | |
| ReactPropTypes = { | |
| array: productionTypeChecker, | |
| bool: productionTypeChecker, | |
| func: productionTypeChecker, | |
| number: productionTypeChecker, | |
| object: productionTypeChecker, | |
| string: productionTypeChecker, | |
| symbol: productionTypeChecker, | |
| any: productionTypeChecker, | |
| arrayOf: getProductionTypeChecker, | |
| element: productionTypeChecker, | |
| instanceOf: getProductionTypeChecker, | |
| node: productionTypeChecker, | |
| objectOf: getProductionTypeChecker, | |
| oneOf: getProductionTypeChecker, | |
| oneOfType: getProductionTypeChecker, | |
| shape: getProductionTypeChecker | |
| }, PropTypeError.prototype = Error.prototype, module.exports = ReactPropTypes; | |
| }, { | |
| "10": 10, | |
| "14": 14, | |
| "21": 21, | |
| "25": 25, | |
| "27": 27, | |
| "28": 28 | |
| } ], | |
| 14: [ function(require, module, exports) { | |
| "use strict"; | |
| module.exports = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"; | |
| }, {} ], | |
| 15: [ function(require, module, exports) { | |
| "use strict"; | |
| module.exports = { | |
| IndeterminateComponent: 0, | |
| FunctionalComponent: 1, | |
| ClassComponent: 2, | |
| HostRoot: 3, | |
| HostPortal: 4, | |
| HostComponent: 5, | |
| HostText: 6, | |
| CoroutineComponent: 7, | |
| CoroutineHandlerPhase: 8, | |
| YieldComponent: 9, | |
| Fragment: 10 | |
| }; | |
| }, {} ], | |
| 16: [ function(require, module, exports) { | |
| "use strict"; | |
| var _assign = require(29), React = require(3), ReactUMDEntry = _assign({ | |
| __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { | |
| ReactCurrentOwner: require(8), | |
| ReactComponentTreeHook: require(7) | |
| } | |
| }, React); | |
| module.exports = ReactUMDEntry; | |
| }, { | |
| "29": 29, | |
| "3": 3, | |
| "7": 7, | |
| "8": 8 | |
| } ], | |
| 17: [ function(require, module, exports) { | |
| "use strict"; | |
| module.exports = "16.0.0-alpha.3"; | |
| }, {} ], | |
| 18: [ function(require, module, exports) { | |
| "use strict"; | |
| module.exports = !1; | |
| }, {} ], | |
| 19: [ function(require, module, exports) { | |
| "use strict"; | |
| function checkPropTypes(e, r, i, a, n) {} | |
| require(23), require(14), require(27), require(28); | |
| module.exports = checkPropTypes; | |
| }, { | |
| "14": 14, | |
| "23": 23, | |
| "27": 27, | |
| "28": 28 | |
| } ], | |
| 20: [ function(require, module, exports) { | |
| "use strict"; | |
| function getComponentName(e) { | |
| if ("function" == typeof e.getName) return e.getName(); | |
| if ("number" == typeof e.tag) { | |
| var t = e, n = t.type; | |
| if ("string" == typeof n) return n; | |
| if ("function" == typeof n) return n.displayName || n.name; | |
| } | |
| return null; | |
| } | |
| module.exports = getComponentName; | |
| }, {} ], | |
| 21: [ function(require, module, exports) { | |
| "use strict"; | |
| function getIteratorFn(t) { | |
| var r = t && (ITERATOR_SYMBOL && t[ITERATOR_SYMBOL] || t["@@iterator"]); | |
| if ("function" == typeof r) return r; | |
| } | |
| var ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator; | |
| module.exports = getIteratorFn; | |
| }, {} ], | |
| 22: [ function(require, module, exports) { | |
| "use strict"; | |
| function onlyChild(e) { | |
| return ReactElement.isValidElement(e) || _prodInvariant("143"), e; | |
| } | |
| var _prodInvariant = require(23), ReactElement = require(10); | |
| require(27); | |
| module.exports = onlyChild; | |
| }, { | |
| "10": 10, | |
| "23": 23, | |
| "27": 27 | |
| } ], | |
| 23: [ function(require, module, exports) { | |
| "use strict"; | |
| function reactProdInvariant(r) { | |
| for (var e = arguments.length - 1, o = "Minified React error #" + r + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant=" + r, n = 0; n < e; n++) o += "&args[]=" + encodeURIComponent(arguments[n + 1]); | |
| o += " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."; | |
| var t = new Error(o); | |
| throw t.name = "Invariant Violation", t.framesToPop = 1, t; | |
| } | |
| module.exports = reactProdInvariant; | |
| }, {} ], | |
| 24: [ function(require, module, exports) { | |
| "use strict"; | |
| function getComponentKey(e, r) { | |
| return e && "object" == typeof e && null != e.key ? KeyEscapeUtils.escape(e.key) : r.toString(36); | |
| } | |
| function traverseAllChildrenImpl(e, r, t, n) { | |
| var l = typeof e; | |
| if ("undefined" !== l && "boolean" !== l || (e = null), null === e || "string" === l || "number" === l || "object" === l && e.$$typeof === REACT_ELEMENT_TYPE) return t(n, e, "" === r ? "." + getComponentKey(e, 0) : r), | |
| 1; | |
| var a, i, o = 0, u = "" === r ? "." : r + ":"; | |
| if (Array.isArray(e)) for (var s = 0; s < e.length; s++) a = e[s], i = u + getComponentKey(a, s), | |
| o += traverseAllChildrenImpl(a, i, t, n); else { | |
| var c = getIteratorFn(e); | |
| if (c) for (var p, v = c.call(e), y = 0; !(p = v.next()).done; ) a = p.value, i = u + getComponentKey(a, y++), | |
| o += traverseAllChildrenImpl(a, i, t, n); else if ("object" === l) { | |
| var b = "" + e; | |
| _prodInvariant("31", "[object Object]" === b ? "object with keys {" + Object.keys(e).join(", ") + "}" : b, ""); | |
| } | |
| } | |
| return o; | |
| } | |
| function traverseAllChildren(e, r, t) { | |
| return null == e ? 0 : traverseAllChildrenImpl(e, "", r, t); | |
| } | |
| var _prodInvariant = require(23), REACT_ELEMENT_TYPE = (require(8), require(11)), getIteratorFn = require(21), KeyEscapeUtils = (require(27), | |
| require(1)); | |
| require(28); | |
| module.exports = traverseAllChildren; | |
| }, { | |
| "1": 1, | |
| "11": 11, | |
| "21": 21, | |
| "23": 23, | |
| "27": 27, | |
| "28": 28, | |
| "8": 8 | |
| } ], | |
| 25: [ function(require, module, exports) { | |
| "use strict"; | |
| function makeEmptyFunction(arg) { | |
| return function() { | |
| return arg; | |
| }; | |
| } | |
| var emptyFunction = function() {}; | |
| emptyFunction.thatReturns = makeEmptyFunction, emptyFunction.thatReturnsFalse = makeEmptyFunction(!1), | |
| emptyFunction.thatReturnsTrue = makeEmptyFunction(!0), emptyFunction.thatReturnsNull = makeEmptyFunction(null), | |
| emptyFunction.thatReturnsThis = function() { | |
| return this; | |
| }, emptyFunction.thatReturnsArgument = function(arg) { | |
| return arg; | |
| }, module.exports = emptyFunction; | |
| }, {} ], | |
| 26: [ function(require, module, exports) { | |
| "use strict"; | |
| var emptyObject = {}; | |
| module.exports = emptyObject; | |
| }, {} ], | |
| 27: [ function(require, module, exports) { | |
| "use strict"; | |
| function invariant(condition, format, a, b, c, d, e, f) { | |
| if (validateFormat(format), !condition) { | |
| var error; | |
| if (void 0 === format) error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); else { | |
| var args = [ a, b, c, d, e, f ], argIndex = 0; | |
| error = new Error(format.replace(/%s/g, function() { | |
| return args[argIndex++]; | |
| })), error.name = "Invariant Violation"; | |
| } | |
| throw error.framesToPop = 1, error; | |
| } | |
| } | |
| var validateFormat = function(format) {}; | |
| module.exports = invariant; | |
| }, {} ], | |
| 28: [ function(require, module, exports) { | |
| "use strict"; | |
| var emptyFunction = require(25), warning = emptyFunction; | |
| module.exports = warning; | |
| }, { | |
| "25": 25 | |
| } ], | |
| 29: [ function(require, module, exports) { | |
| /* | |
| object-assign | |
| (c) Sindre Sorhus | |
| @license MIT | |
| */ | |
| "use strict"; | |
| function toObject(val) { | |
| if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined"); | |
| return Object(val); | |
| } | |
| function shouldUseNative() { | |
| try { | |
| if (!Object.assign) return !1; | |
| var test1 = new String("abc"); | |
| if (test1[5] = "de", "5" === Object.getOwnPropertyNames(test1)[0]) return !1; | |
| for (var test2 = {}, i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i; | |
| if ("0123456789" !== Object.getOwnPropertyNames(test2).map(function(n) { | |
| return test2[n]; | |
| }).join("")) return !1; | |
| var test3 = {}; | |
| return "abcdefghijklmnopqrst".split("").forEach(function(letter) { | |
| test3[letter] = letter; | |
| }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, test3)).join(""); | |
| } catch (err) { | |
| return !1; | |
| } | |
| } | |
| var getOwnPropertySymbols = Object.getOwnPropertySymbols, hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable; | |
| module.exports = shouldUseNative() ? Object.assign : function(target, source) { | |
| for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) { | |
| from = Object(arguments[s]); | |
| for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]); | |
| if (getOwnPropertySymbols) { | |
| symbols = getOwnPropertySymbols(from); | |
| for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]); | |
| } | |
| } | |
| return to; | |
| }; | |
| }, {} ] | |
| }, {}, [ 16 ])(16); | |
| }); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment