├── test ├── test_helper.exs └── elixir_script_react_test.exs ├── .tool-versions ├── src ├── react_dom.index.js └── react.index.js ├── lib ├── react.ex ├── react_dom.ex └── react │ ├── tags.txt │ └── html.ex ├── .gitignore ├── package.json ├── mix.lock ├── CHANGELOG.md ├── mix.exs ├── config └── config.exs ├── rollup.build.js ├── README.md └── priv └── elixir_script └── react.js /test/test_helper.exs: -------------------------------------------------------------------------------- 1 | ExUnit.start() 2 | -------------------------------------------------------------------------------- /.tool-versions: -------------------------------------------------------------------------------- 1 | erlang 20.1 2 | elixir 1.6.0-otp-20 3 | nodejs 9.5.0 4 | -------------------------------------------------------------------------------- /test/elixir_script_react_test.exs: -------------------------------------------------------------------------------- 1 | defmodule ElixirScriptReactTest do 2 | use ExUnit.Case 3 | doctest ElixirScriptReact 4 | 5 | test "greets the world" do 6 | assert ElixirScriptReact.hello() == :world 7 | end 8 | end 9 | -------------------------------------------------------------------------------- /src/react_dom.index.js: -------------------------------------------------------------------------------- 1 | import React from 'react'; 2 | import ReactDOM from 'react-dom'; 3 | 4 | function render(element, container_query) { 5 | const container = document.querySelector(container_query); 6 | return ReactDOM.render(element, container); 7 | } 8 | 9 | export default { 10 | render 11 | }; 12 | -------------------------------------------------------------------------------- /lib/react.ex: -------------------------------------------------------------------------------- 1 | defmodule React do 2 | @moduledoc """ 3 | FFI Module for interacting with the [React](https://facebook.github.io/react/) 4 | JavaScript module. 5 | """ 6 | use ElixirScript.FFI 7 | 8 | @doc """ 9 | Creates a React Element 10 | 11 | ```elixir 12 | props = %{"hello" => world} 13 | children = [] 14 | 15 | React.createElement("div", props, children) 16 | ``` 17 | """ 18 | defexternal createElement(type, props, children) 19 | end 20 | -------------------------------------------------------------------------------- /lib/react_dom.ex: -------------------------------------------------------------------------------- 1 | defmodule ReactDOM do 2 | @moduledoc """ 3 | FFI Module for interacting with the ReactDOM 4 | JavaScript module. 5 | """ 6 | use ElixirScript.FFI 7 | 8 | 9 | @doc """ 10 | Renders a React Element to the given DOM container 11 | 12 | ```elixir 13 | ReactDOM.render(my_react_element, "#my_container") 14 | ``` 15 | 16 | Container is any value allowed by [document.querySelector](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector) 17 | """ 18 | defexternal render(element, container) 19 | end 20 | -------------------------------------------------------------------------------- /src/react.index.js: -------------------------------------------------------------------------------- 1 | import React from 'react'; 2 | 3 | function mapToObject(map) { 4 | const object = {}; 5 | 6 | for (const [key, value] of map.entries()) { 7 | if (value instanceof Map) { 8 | object[key] = mapToObject(value); 9 | } else { 10 | object[key] = value; 11 | } 12 | } 13 | 14 | return object; 15 | } 16 | 17 | function createElement(tag, attributes, elements) { 18 | const props = mapToObject(attributes); 19 | return React.createElement(tag, props, ...elements); 20 | } 21 | 22 | export default { 23 | createElement 24 | }; 25 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # The directory Mix will write compiled artifacts to. 2 | /_build/ 3 | 4 | # If you run "mix test --cover", coverage assets end up here. 5 | /cover/ 6 | 7 | # The directory Mix downloads your dependencies sources to. 8 | /deps/ 9 | 10 | # Where 3rd-party dependencies like ExDoc output generated docs. 11 | /doc/ 12 | 13 | # Ignore .fetch files in case you like to edit your project deps locally. 14 | /.fetch 15 | 16 | # If the VM crashes, it generates a dump, let's ignore it too. 17 | erl_crash.dump 18 | 19 | # Also ignore archive artifacts (built via "mix archive.build"). 20 | *.ez 21 | 22 | node_modules 23 | 24 | .elixir_ls 25 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "elixirscript_react", 3 | "version": "1.0.0", 4 | "description": "**TODO: Add description**", 5 | "main": "src/index.js", 6 | "directories": { 7 | "lib": "lib", 8 | "test": "test" 9 | }, 10 | "scripts": { 11 | "build": "node rollup.build.js" 12 | }, 13 | "author": "", 14 | "license": "MIT", 15 | "dependencies": { 16 | "babel-preset-env": "^1.6.1", 17 | "react": "^16.2.0", 18 | "react-dom": "^16.2.0", 19 | "rollup": "^0.56.2", 20 | "rollup-plugin-babel": "^3.0.3", 21 | "rollup-plugin-commonjs": "^8.3.0", 22 | "rollup-plugin-node-resolve": "^3.0.3" 23 | }, 24 | "devDependencies": { 25 | "babel-core": "^6.26.0" 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /mix.lock: -------------------------------------------------------------------------------- 1 | %{ 2 | "earmark": {:hex, :earmark, "1.2.4", "99b637c62a4d65a20a9fb674b8cffb8baa771c04605a80c911c4418c69b75439", [:mix], [], "hexpm"}, 3 | "elixir_script": {:hex, :elixir_script, "0.32.0", "33c0348a891baa35e1b3802af776cddf83d27988debdea78a0ef0c0c65324146", [:mix], [{:estree, "~> 2.6", [hex: :estree, repo: "hexpm", optional: false]}], "hexpm"}, 4 | "estree": {:hex, :estree, "2.6.1", "0a17cc0e9e35315dc4fcd79d30a746b1f3e9ed654be6084ce882ab491165ae22", [:mix], [], "hexpm"}, 5 | "ex_doc": {:hex, :ex_doc, "0.18.3", "f4b0e4a2ec6f333dccf761838a4b253d75e11f714b85ae271c9ae361367897b7", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}], "hexpm"}, 6 | "fs": {:hex, :fs, "3.4.0", "6d18575c250b415b3cad559e6f97a4c822516c7bc2c10bfbb2493a8f230f5132", [], [], "hexpm"}, 7 | } 8 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | All notable changes to this project will be documented in this file. 4 | 5 | The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) 6 | and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). 7 | 8 | ## [16.2.0] - 2018-03-17 9 | 10 | ### Added 11 | 12 | * Updated version of React 13 | 14 | ## [1.0.2] - 2017-08-25 15 | 16 | ### Fixed 17 | 18 | * Fix error in mapToObject in src/react.index.js 19 | 20 | ## [1.0.1] - 2017-08-20 21 | 22 | ### Fixed 23 | 24 | * Typo in documentation for `React.createElement/3` 25 | 26 | ## [1.0.0] - 2017-08-19 27 | 28 | ### Added 29 | 30 | * `React.HTML` module for defining HTML React macros 31 | * `React` FFI module with `createElement/3` 32 | * `ReactDOM` FFI module with `render/2` 33 | -------------------------------------------------------------------------------- /mix.exs: -------------------------------------------------------------------------------- 1 | defmodule ElixirScriptReact.Mixfile do 2 | use Mix.Project 3 | 4 | def project do 5 | [ 6 | app: :elixir_script_react, 7 | version: "16.2.0", 8 | elixir: "~> 1.6", 9 | start_permanent: Mix.env == :prod, 10 | deps: deps(), 11 | package: package(), 12 | description: description() 13 | ] 14 | end 15 | 16 | def application do 17 | [ 18 | extra_applications: [:logger] 19 | ] 20 | end 21 | 22 | defp deps do 23 | [ 24 | {:elixir_script, "~> 0.32"}, 25 | {:ex_doc, "~> 0.18", only: :dev} 26 | ] 27 | end 28 | 29 | defp description do 30 | """ 31 | React library for ElixirScript 32 | """ 33 | end 34 | 35 | defp package do 36 | [ 37 | files: ["lib", "priv/**/*.*", "mix.exs", "README.md", "CHANGELOG.md"], 38 | maintainers: ["Bryan Joseph"], 39 | licenses: ["BSD-3"], 40 | links: %{ 41 | "GitHub" => "https://github.com/elixirscript/elixirscript_react" 42 | }, 43 | build_tools: ["mix"] 44 | ] 45 | end 46 | end 47 | -------------------------------------------------------------------------------- /lib/react/tags.txt: -------------------------------------------------------------------------------- 1 | a 2 | abbr 3 | address 4 | area 5 | article 6 | aside 7 | audio 8 | b 9 | base 10 | bdi 11 | bdo 12 | blockquote 13 | body 14 | br 15 | button 16 | canvas 17 | caption 18 | cite 19 | code 20 | col 21 | colgroup 22 | command 23 | datalist 24 | dd 25 | del 26 | details 27 | dfn 28 | dialog 29 | div 30 | dl 31 | dt 32 | em 33 | embed 34 | fieldset 35 | figcaption 36 | figure 37 | footer 38 | form 39 | h1 40 | h2 41 | h3 42 | h4 43 | head 44 | header 45 | hgroup 46 | hr 47 | html 48 | i 49 | iframe 50 | img 51 | input 52 | ins 53 | kbd 54 | keygen 55 | label 56 | legend 57 | li 58 | link 59 | main 60 | map 61 | mark 62 | menu 63 | menuitem 64 | meta 65 | meter 66 | nav 67 | noscript 68 | object 69 | ol 70 | optgroup 71 | option 72 | output 73 | p 74 | param 75 | pre 76 | progress 77 | q 78 | rp 79 | rt 80 | ruby 81 | s 82 | samp 83 | script 84 | section 85 | select 86 | small 87 | source 88 | span 89 | strong 90 | style 91 | sub 92 | summary 93 | sup 94 | table 95 | tbody 96 | td 97 | textarea 98 | tfoot 99 | th 100 | thead 101 | time 102 | title 103 | tr 104 | track 105 | u 106 | ul 107 | var 108 | video 109 | wbr 110 | -------------------------------------------------------------------------------- /config/config.exs: -------------------------------------------------------------------------------- 1 | # This file is responsible for configuring your application 2 | # and its dependencies with the aid of the Mix.Config module. 3 | use Mix.Config 4 | 5 | # This configuration is loaded before any dependency and is restricted 6 | # to this project. If another project depends on this project, this 7 | # file won't be loaded nor affect the parent project. For this reason, 8 | # if you want to provide default values for your application for 9 | # 3rd-party users, it should be done in your "mix.exs" file. 10 | 11 | # You can configure your application as: 12 | # 13 | # config :elixir_script_react, key: :value 14 | # 15 | # and access this configuration in your application as: 16 | # 17 | # Application.get_env(:elixir_script_react, :key) 18 | # 19 | # You can also configure a 3rd-party app: 20 | # 21 | # config :logger, level: :info 22 | # 23 | 24 | # It is also possible to import configuration files, relative to this 25 | # directory. For example, you can emulate configuration per environment 26 | # by uncommenting the line below and defining dev.exs, test.exs and such. 27 | # Configuration from the imported file will override the ones defined 28 | # here (which is why it is important to import them last). 29 | # 30 | # import_config "#{Mix.env}.exs" 31 | -------------------------------------------------------------------------------- /rollup.build.js: -------------------------------------------------------------------------------- 1 | const rollup = require('rollup'); 2 | const babel = require('rollup-plugin-babel'); 3 | const resolve = require('rollup-plugin-node-resolve'); 4 | const commonjs = require('rollup-plugin-commonjs'); 5 | 6 | const plugins = [ 7 | resolve({}), 8 | commonjs(), 9 | babel({ 10 | babelrc: false, 11 | presets: [ 12 | [ 13 | 'env', 14 | { 15 | targets: { 16 | node: 'current', 17 | }, 18 | modules: false, 19 | loose: true, 20 | }, 21 | ], 22 | ], 23 | }), 24 | ]; 25 | 26 | async function build() { 27 | let inputOptions = { 28 | input: 'src/react.index.js', 29 | plugins: plugins, 30 | }; 31 | 32 | let outputOptions = { 33 | format: 'es', 34 | file: 'priv/elixir_script/react.js', 35 | sourcemap: 'inline', 36 | }; 37 | 38 | let bundle = await rollup.rollup(inputOptions); 39 | await bundle.write(outputOptions); 40 | 41 | inputOptions = { 42 | input: 'src/react_dom.index.js', 43 | plugins: plugins, 44 | }; 45 | 46 | outputOptions = { 47 | format: 'es', 48 | file: 'priv/elixir_script/react_dom.js', 49 | sourcemap: 'inline', 50 | }; 51 | 52 | bundle = await rollup.rollup(inputOptions); 53 | await bundle.write(outputOptions); 54 | } 55 | 56 | build(); 57 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ElixirScriptReact 2 | 3 | A library for using [React](https://facebook.github.io/react/) with ElixirScript 4 | 5 | ## Example 6 | 7 | ```elixir 8 | use React.HTML 9 | 10 | def my_section() 11 | section id: "todoapp" do 12 | header id: "header" do 13 | h1 do 14 | "todos" 15 | end 16 | input [ 17 | id: "new-todo", 18 | placeholder: "What needs to be done?", 19 | autoFocus: true, 20 | onKeyPress: fn(event, _) -> process_event(event) end 21 | ] 22 | end 23 | end 24 | end 25 | 26 | ReactDOM.render(my_section(), "my_dom_container_query") 27 | ``` 28 | 29 | `my_dom_container_query` is a string that is passed to `document.querySelector` in the browser 30 | 31 | ## Installation 32 | 33 | If [available in Hex](https://hex.pm/docs/publish), the package can be installed 34 | by adding `elixir_script_react` to your list of dependencies in `mix.exs`: 35 | 36 | ```elixir 37 | def deps do 38 | [ 39 | {:elixir_script_react, "~> 16.2.0"} 40 | ] 41 | end 42 | ``` 43 | 44 | Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc) 45 | and published on [HexDocs](https://hexdocs.pm). Once published, the docs can 46 | be found at [https://hexdocs.pm/elixir_script_react](https://hexdocs.pm/elixir_script_react). 47 | -------------------------------------------------------------------------------- /lib/react/html.ex: -------------------------------------------------------------------------------- 1 | defmodule React.HTML do 2 | @moduledoc """ 3 | Defines macros for creating React HTML elements. 4 | """ 5 | 6 | defmacro __using__(_) do 7 | quote do 8 | import React.HTML 9 | end 10 | end 11 | 12 | @external_resource tags_path = Path.join([__DIR__, "tags.txt"]) 13 | 14 | @tags (for line <- File.stream!(tags_path, [], :line) do 15 | line |> String.trim |> String.to_atom 16 | end) 17 | 18 | for tag <- @tags do 19 | @doc """ 20 | Defines a macro for the html element, #{tag} 21 | """ 22 | defmacro unquote(tag)(attrs, do: inner) do 23 | tag = Atom.to_string(unquote(tag)) 24 | { inner, attributes } = do_tag(inner, attrs) 25 | 26 | quote do 27 | React.createElement(unquote(tag), unquote(attributes), unquote(inner)) 28 | end 29 | end 30 | 31 | defmacro unquote(tag)(attrs \\ []) do 32 | tag = Atom.to_string(unquote(tag)) 33 | 34 | { inner, attributes } = Keyword.pop(attrs, :do) 35 | { inner, attributes } = do_tag(inner, attributes) 36 | 37 | quote do 38 | React.createElement(unquote(tag), unquote(attributes), unquote(inner)) 39 | end 40 | end 41 | end 42 | 43 | defp do_tag(inner, attributes) do 44 | inner = case inner do 45 | {:__block__, _, params} -> 46 | params 47 | nil -> 48 | [] 49 | x -> 50 | [x] 51 | end 52 | 53 | attributes = config_to_map(attributes) 54 | 55 | {inner, attributes} 56 | end 57 | 58 | defp config_to_map(config) do 59 | config = Enum.map(config, fn({key, value}) -> 60 | if is_atom(key) do 61 | {Atom.to_string(key), value} 62 | else 63 | {key, value} 64 | end 65 | end) 66 | 67 | {:%{}, [], config} 68 | end 69 | 70 | end 71 | -------------------------------------------------------------------------------- /priv/elixir_script/react.js: -------------------------------------------------------------------------------- 1 | function createCommonjsModule(fn, module) { 2 | return module = { exports: {} }, fn(module, module.exports), module.exports; 3 | } 4 | 5 | /* 6 | object-assign 7 | (c) Sindre Sorhus 8 | @license MIT 9 | */ 10 | /* eslint-disable no-unused-vars */ 11 | 12 | var getOwnPropertySymbols = Object.getOwnPropertySymbols; 13 | var hasOwnProperty = Object.prototype.hasOwnProperty; 14 | var propIsEnumerable = Object.prototype.propertyIsEnumerable; 15 | 16 | function toObject(val) { 17 | if (val === null || val === undefined) { 18 | throw new TypeError('Object.assign cannot be called with null or undefined'); 19 | } 20 | 21 | return Object(val); 22 | } 23 | 24 | function shouldUseNative() { 25 | try { 26 | if (!Object.assign) { 27 | return false; 28 | } 29 | 30 | // Detect buggy property enumeration order in older V8 versions. 31 | 32 | // https://bugs.chromium.org/p/v8/issues/detail?id=4118 33 | var test1 = new String('abc'); // eslint-disable-line no-new-wrappers 34 | test1[5] = 'de'; 35 | if (Object.getOwnPropertyNames(test1)[0] === '5') { 36 | return false; 37 | } 38 | 39 | // https://bugs.chromium.org/p/v8/issues/detail?id=3056 40 | var test2 = {}; 41 | for (var i = 0; i < 10; i++) { 42 | test2['_' + String.fromCharCode(i)] = i; 43 | } 44 | var order2 = Object.getOwnPropertyNames(test2).map(function (n) { 45 | return test2[n]; 46 | }); 47 | if (order2.join('') !== '0123456789') { 48 | return false; 49 | } 50 | 51 | // https://bugs.chromium.org/p/v8/issues/detail?id=3056 52 | var test3 = {}; 53 | 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { 54 | test3[letter] = letter; 55 | }); 56 | if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') { 57 | return false; 58 | } 59 | 60 | return true; 61 | } catch (err) { 62 | // We don't expect any of the above to throw, but better to be safe. 63 | return false; 64 | } 65 | } 66 | 67 | var objectAssign = shouldUseNative() ? Object.assign : function (target, source) { 68 | var from; 69 | var to = toObject(target); 70 | var symbols; 71 | 72 | for (var s = 1; s < arguments.length; s++) { 73 | from = Object(arguments[s]); 74 | 75 | for (var key in from) { 76 | if (hasOwnProperty.call(from, key)) { 77 | to[key] = from[key]; 78 | } 79 | } 80 | 81 | if (getOwnPropertySymbols) { 82 | symbols = getOwnPropertySymbols(from); 83 | for (var i = 0; i < symbols.length; i++) { 84 | if (propIsEnumerable.call(from, symbols[i])) { 85 | to[symbols[i]] = from[symbols[i]]; 86 | } 87 | } 88 | } 89 | } 90 | 91 | return to; 92 | }; 93 | 94 | /** 95 | * Copyright (c) 2013-present, Facebook, Inc. 96 | * 97 | * This source code is licensed under the MIT license found in the 98 | * LICENSE file in the root directory of this source tree. 99 | * 100 | */ 101 | 102 | var emptyObject = {}; 103 | 104 | if (process.env.NODE_ENV !== 'production') { 105 | Object.freeze(emptyObject); 106 | } 107 | 108 | var emptyObject_1 = emptyObject; 109 | 110 | /** 111 | * Copyright (c) 2013-present, Facebook, Inc. 112 | * 113 | * This source code is licensed under the MIT license found in the 114 | * LICENSE file in the root directory of this source tree. 115 | * 116 | * 117 | */ 118 | 119 | function makeEmptyFunction(arg) { 120 | return function () { 121 | return arg; 122 | }; 123 | } 124 | 125 | /** 126 | * This function accepts and discards inputs; it has no side effects. This is 127 | * primarily useful idiomatically for overridable function endpoints which 128 | * always need to be callable, since JS lacks a null-call idiom ala Cocoa. 129 | */ 130 | var emptyFunction = function emptyFunction() {}; 131 | 132 | emptyFunction.thatReturns = makeEmptyFunction; 133 | emptyFunction.thatReturnsFalse = makeEmptyFunction(false); 134 | emptyFunction.thatReturnsTrue = makeEmptyFunction(true); 135 | emptyFunction.thatReturnsNull = makeEmptyFunction(null); 136 | emptyFunction.thatReturnsThis = function () { 137 | return this; 138 | }; 139 | emptyFunction.thatReturnsArgument = function (arg) { 140 | return arg; 141 | }; 142 | 143 | var emptyFunction_1 = emptyFunction; 144 | 145 | var q = "function" === typeof Symbol && Symbol["for"], 146 | r = q ? Symbol["for"]("react.element") : 60103, 147 | t = q ? Symbol["for"]("react.call") : 60104, 148 | u = q ? Symbol["for"]("react.return") : 60105, 149 | v = q ? Symbol["for"]("react.portal") : 60106, 150 | w = q ? Symbol["for"]("react.fragment") : 60107, 151 | x = "function" === typeof Symbol && Symbol.iterator; 152 | function y(a) { 153 | for (var b = arguments.length - 1, e = "Minified React error #" + a + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant\x3d" + a, c = 0; c < b; c++) e += "\x26args[]\x3d" + encodeURIComponent(arguments[c + 1]);b = Error(e + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");b.name = "Invariant Violation";b.framesToPop = 1;throw b; 154 | } 155 | var z = { isMounted: function () { 156 | return !1; 157 | }, enqueueForceUpdate: function () {}, enqueueReplaceState: function () {}, enqueueSetState: function () {} };function A(a, b, e) { 158 | this.props = a;this.context = b;this.refs = emptyObject_1;this.updater = e || z; 159 | }A.prototype.isReactComponent = {};A.prototype.setState = function (a, b) { 160 | "object" !== typeof a && "function" !== typeof a && null != a ? y("85") : void 0;this.updater.enqueueSetState(this, a, b, "setState"); 161 | };A.prototype.forceUpdate = function (a) { 162 | this.updater.enqueueForceUpdate(this, a, "forceUpdate"); 163 | }; 164 | function B(a, b, e) { 165 | this.props = a;this.context = b;this.refs = emptyObject_1;this.updater = e || z; 166 | }function C() {}C.prototype = A.prototype;var D = B.prototype = new C();D.constructor = B;objectAssign(D, A.prototype);D.isPureReactComponent = !0;function E(a, b, e) { 167 | this.props = a;this.context = b;this.refs = emptyObject_1;this.updater = e || z; 168 | }var F = E.prototype = new C();F.constructor = E;objectAssign(F, A.prototype);F.unstable_isAsyncReactComponent = !0;F.render = function () { 169 | return this.props.children; 170 | };var G = { current: null }, 171 | H = Object.prototype.hasOwnProperty, 172 | I = { key: !0, ref: !0, __self: !0, __source: !0 }; 173 | function J(a, b, e) { 174 | var c, 175 | d = {}, 176 | g = null, 177 | k = null;if (null != b) for (c in void 0 !== b.ref && (k = b.ref), void 0 !== b.key && (g = "" + b.key), b) H.call(b, c) && !I.hasOwnProperty(c) && (d[c] = b[c]);var f = arguments.length - 2;if (1 === f) d.children = e;else if (1 < f) { 178 | for (var h = Array(f), l = 0; l < f; l++) h[l] = arguments[l + 2];d.children = h; 179 | }if (a && a.defaultProps) for (c in f = a.defaultProps, f) void 0 === d[c] && (d[c] = f[c]);return { $$typeof: r, type: a, key: g, ref: k, props: d, _owner: G.current }; 180 | }function K(a) { 181 | return "object" === typeof a && null !== a && a.$$typeof === r; 182 | } 183 | function escape(a) { 184 | var b = { "\x3d": "\x3d0", ":": "\x3d2" };return "$" + ("" + a).replace(/[=:]/g, function (a) { 185 | return b[a]; 186 | }); 187 | }var L = /\/+/g, 188 | M = [];function N(a, b, e, c) { 189 | if (M.length) { 190 | var d = M.pop();d.result = a;d.keyPrefix = b;d.func = e;d.context = c;d.count = 0;return d; 191 | }return { result: a, keyPrefix: b, func: e, context: c, count: 0 }; 192 | }function O(a) { 193 | a.result = null;a.keyPrefix = null;a.func = null;a.context = null;a.count = 0;10 > M.length && M.push(a); 194 | } 195 | function P(a, b, e, c) { 196 | var d = typeof a;if ("undefined" === d || "boolean" === d) a = null;var g = !1;if (null === a) g = !0;else switch (d) {case "string":case "number": 197 | g = !0;break;case "object": 198 | switch (a.$$typeof) {case r:case t:case u:case v: 199 | g = !0;}}if (g) return e(c, a, "" === b ? "." + Q(a, 0) : b), 1;g = 0;b = "" === b ? "." : b + ":";if (Array.isArray(a)) for (var k = 0; k < a.length; k++) { 200 | d = a[k];var f = b + Q(d, k);g += P(d, f, e, c); 201 | } else if (null === a || "undefined" === typeof a ? f = null : (f = x && a[x] || a["@@iterator"], f = "function" === typeof f ? f : null), "function" === typeof f) for (a = f.call(a), k = 0; !(d = a.next()).done;) d = d.value, f = b + Q(d, k++), g += P(d, f, e, c);else "object" === d && (e = "" + a, y("31", "[object Object]" === e ? "object with keys {" + Object.keys(a).join(", ") + "}" : e, ""));return g; 202 | }function Q(a, b) { 203 | return "object" === typeof a && null !== a && null != a.key ? escape(a.key) : b.toString(36); 204 | }function R(a, b) { 205 | a.func.call(a.context, b, a.count++); 206 | } 207 | function S(a, b, e) { 208 | var c = a.result, 209 | d = a.keyPrefix;a = a.func.call(a.context, b, a.count++);Array.isArray(a) ? T(a, c, e, emptyFunction_1.thatReturnsArgument) : null != a && (K(a) && (b = d + (!a.key || b && b.key === a.key ? "" : ("" + a.key).replace(L, "$\x26/") + "/") + e, a = { $$typeof: r, type: a.type, key: b, ref: a.ref, props: a.props, _owner: a._owner }), c.push(a)); 210 | }function T(a, b, e, c, d) { 211 | var g = "";null != e && (g = ("" + e).replace(L, "$\x26/") + "/");b = N(b, g, c, d);null == a || P(a, "", S, b);O(b); 212 | } 213 | var U = { Children: { map: function (a, b, e) { 214 | if (null == a) return a;var c = [];T(a, c, null, b, e);return c; 215 | }, forEach: function (a, b, e) { 216 | if (null == a) return a;b = N(null, null, b, e);null == a || P(a, "", R, b);O(b); 217 | }, count: function (a) { 218 | return null == a ? 0 : P(a, "", emptyFunction_1.thatReturnsNull, null); 219 | }, toArray: function (a) { 220 | var b = [];T(a, b, null, emptyFunction_1.thatReturnsArgument);return b; 221 | }, only: function (a) { 222 | K(a) ? void 0 : y("143");return a; 223 | } }, Component: A, PureComponent: B, unstable_AsyncComponent: E, Fragment: w, createElement: J, cloneElement: function (a, b, e) { 224 | var c = objectAssign({}, a.props), 225 | d = a.key, 226 | g = a.ref, 227 | k = a._owner;if (null != b) { 228 | void 0 !== b.ref && (g = b.ref, k = G.current);void 0 !== b.key && (d = "" + b.key);if (a.type && a.type.defaultProps) var f = a.type.defaultProps;for (h in b) H.call(b, h) && !I.hasOwnProperty(h) && (c[h] = void 0 === b[h] && void 0 !== f ? f[h] : b[h]); 229 | }var h = arguments.length - 2;if (1 === h) c.children = e;else if (1 < h) { 230 | f = Array(h);for (var l = 0; l < h; l++) f[l] = arguments[l + 2];c.children = f; 231 | }return { $$typeof: r, type: a.type, key: d, ref: g, props: c, _owner: k }; 232 | }, createFactory: function (a) { 233 | var b = J.bind(null, a);b.type = a;return b; 234 | }, 235 | isValidElement: K, version: "16.2.0", __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { ReactCurrentOwner: G, assign: objectAssign } }, 236 | V = Object.freeze({ default: U }), 237 | W = V && U || V;var react_production_min = W["default"] ? W["default"] : W; 238 | 239 | /** 240 | * Copyright (c) 2013-present, Facebook, Inc. 241 | * 242 | * This source code is licensed under the MIT license found in the 243 | * LICENSE file in the root directory of this source tree. 244 | * 245 | */ 246 | 247 | /** 248 | * Use invariant() to assert state which your program assumes to be true. 249 | * 250 | * Provide sprintf-style format (only %s is supported) and arguments 251 | * to provide information about what broke and what you were 252 | * expecting. 253 | * 254 | * The invariant message will be stripped in production, but the invariant 255 | * will remain to ensure logic does not differ in production. 256 | */ 257 | 258 | var validateFormat = function validateFormat(format) {}; 259 | 260 | if (process.env.NODE_ENV !== 'production') { 261 | validateFormat = function validateFormat(format) { 262 | if (format === undefined) { 263 | throw new Error('invariant requires an error message argument'); 264 | } 265 | }; 266 | } 267 | 268 | function invariant(condition, format, a, b, c, d, e, f) { 269 | validateFormat(format); 270 | 271 | if (!condition) { 272 | var error; 273 | if (format === undefined) { 274 | error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); 275 | } else { 276 | var args = [a, b, c, d, e, f]; 277 | var argIndex = 0; 278 | error = new Error(format.replace(/%s/g, function () { 279 | return args[argIndex++]; 280 | })); 281 | error.name = 'Invariant Violation'; 282 | } 283 | 284 | error.framesToPop = 1; // we don't care about invariant's own frame 285 | throw error; 286 | } 287 | } 288 | 289 | var invariant_1 = invariant; 290 | 291 | /** 292 | * Similar to invariant but only logs a warning if the condition is not met. 293 | * This can be used to log issues in development environments in critical 294 | * paths. Removing the logging code for production environments will keep the 295 | * same logic and follow the same code paths. 296 | */ 297 | 298 | var warning = emptyFunction_1; 299 | 300 | if (process.env.NODE_ENV !== 'production') { 301 | var printWarning = function printWarning(format) { 302 | for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 303 | args[_key - 1] = arguments[_key]; 304 | } 305 | 306 | var argIndex = 0; 307 | var message = 'Warning: ' + format.replace(/%s/g, function () { 308 | return args[argIndex++]; 309 | }); 310 | if (typeof console !== 'undefined') { 311 | console.error(message); 312 | } 313 | try { 314 | // --- Welcome to debugging React --- 315 | // This error was thrown as a convenience so that you can use this stack 316 | // to find the callsite that caused this warning to fire. 317 | throw new Error(message); 318 | } catch (x) {} 319 | }; 320 | 321 | warning = function warning(condition, format) { 322 | if (format === undefined) { 323 | throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); 324 | } 325 | 326 | if (format.indexOf('Failed Composite propType: ') === 0) { 327 | return; // Ignore CompositeComponent proptype check. 328 | } 329 | 330 | if (!condition) { 331 | for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { 332 | args[_key2 - 2] = arguments[_key2]; 333 | } 334 | 335 | printWarning.apply(undefined, [format].concat(args)); 336 | } 337 | }; 338 | } 339 | 340 | var warning_1 = warning; 341 | 342 | /** 343 | * Copyright (c) 2013-present, Facebook, Inc. 344 | * 345 | * This source code is licensed under the MIT license found in the 346 | * LICENSE file in the root directory of this source tree. 347 | */ 348 | 349 | var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; 350 | 351 | var ReactPropTypesSecret_1 = ReactPropTypesSecret; 352 | 353 | if (process.env.NODE_ENV !== 'production') { 354 | var invariant$1 = invariant_1; 355 | var warning$1 = warning_1; 356 | var ReactPropTypesSecret$1 = ReactPropTypesSecret_1; 357 | var loggedTypeFailures = {}; 358 | } 359 | 360 | /** 361 | * Assert that the values match with the type specs. 362 | * Error messages are memorized and will only be shown once. 363 | * 364 | * @param {object} typeSpecs Map of name to a ReactPropType 365 | * @param {object} values Runtime values that need to be type-checked 366 | * @param {string} location e.g. "prop", "context", "child context" 367 | * @param {string} componentName Name of the component for error messages. 368 | * @param {?Function} getStack Returns the component stack. 369 | * @private 370 | */ 371 | function checkPropTypes(typeSpecs, values, location, componentName, getStack) { 372 | if (process.env.NODE_ENV !== 'production') { 373 | for (var typeSpecName in typeSpecs) { 374 | if (typeSpecs.hasOwnProperty(typeSpecName)) { 375 | var error; 376 | // Prop type validation may throw. In case they do, we don't want to 377 | // fail the render phase where it didn't fail before. So we log it. 378 | // After these have been cleaned up, we'll let them throw. 379 | try { 380 | // This is intentionally an invariant that gets caught. It's the same 381 | // behavior as without this statement except with a better message. 382 | invariant$1(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]); 383 | error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1); 384 | } catch (ex) { 385 | error = ex; 386 | } 387 | warning$1(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error); 388 | if (error instanceof Error && !(error.message in loggedTypeFailures)) { 389 | // Only monitor this failure once because there tends to be a lot of the 390 | // same error. 391 | loggedTypeFailures[error.message] = true; 392 | 393 | var stack = getStack ? getStack() : ''; 394 | 395 | warning$1(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : ''); 396 | } 397 | } 398 | } 399 | } 400 | } 401 | 402 | var checkPropTypes_1 = checkPropTypes; 403 | 404 | var react_development = createCommonjsModule(function (module) { 405 | 406 | if (process.env.NODE_ENV !== "production") { 407 | (function () { 408 | 409 | var _assign = objectAssign; 410 | var emptyObject = emptyObject_1; 411 | var invariant = invariant_1; 412 | var warning = warning_1; 413 | var emptyFunction = emptyFunction_1; 414 | var checkPropTypes = checkPropTypes_1; 415 | 416 | // TODO: this is special because it gets imported during build. 417 | 418 | var ReactVersion = '16.2.0'; 419 | 420 | // The Symbol used to tag the ReactElement-like types. If there is no native Symbol 421 | // nor polyfill, then a plain number is used for performance. 422 | var hasSymbol = typeof Symbol === 'function' && Symbol['for']; 423 | 424 | var REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7; 425 | var REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8; 426 | var REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9; 427 | var REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca; 428 | var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb; 429 | 430 | var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; 431 | var FAUX_ITERATOR_SYMBOL = '@@iterator'; 432 | 433 | function getIteratorFn(maybeIterable) { 434 | if (maybeIterable === null || typeof maybeIterable === 'undefined') { 435 | return null; 436 | } 437 | var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; 438 | if (typeof maybeIterator === 'function') { 439 | return maybeIterator; 440 | } 441 | return null; 442 | } 443 | 444 | /** 445 | * WARNING: DO NOT manually require this module. 446 | * This is a replacement for `invariant(...)` used by the error code system 447 | * and will _only_ be required by the corresponding babel pass. 448 | * It always throws. 449 | */ 450 | 451 | /** 452 | * Forked from fbjs/warning: 453 | * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js 454 | * 455 | * Only change is we use console.warn instead of console.error, 456 | * and do nothing when 'console' is not supported. 457 | * This really simplifies the code. 458 | * --- 459 | * Similar to invariant but only logs a warning if the condition is not met. 460 | * This can be used to log issues in development environments in critical 461 | * paths. Removing the logging code for production environments will keep the 462 | * same logic and follow the same code paths. 463 | */ 464 | 465 | var lowPriorityWarning = function () {}; 466 | 467 | { 468 | var printWarning = function (format) { 469 | for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 470 | args[_key - 1] = arguments[_key]; 471 | } 472 | 473 | var argIndex = 0; 474 | var message = 'Warning: ' + format.replace(/%s/g, function () { 475 | return args[argIndex++]; 476 | }); 477 | if (typeof console !== 'undefined') { 478 | console.warn(message); 479 | } 480 | try { 481 | // --- Welcome to debugging React --- 482 | // This error was thrown as a convenience so that you can use this stack 483 | // to find the callsite that caused this warning to fire. 484 | throw new Error(message); 485 | } catch (x) {} 486 | }; 487 | 488 | lowPriorityWarning = function (condition, format) { 489 | if (format === undefined) { 490 | throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); 491 | } 492 | if (!condition) { 493 | for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { 494 | args[_key2 - 2] = arguments[_key2]; 495 | } 496 | 497 | printWarning.apply(undefined, [format].concat(args)); 498 | } 499 | }; 500 | } 501 | 502 | var lowPriorityWarning$1 = lowPriorityWarning; 503 | 504 | var didWarnStateUpdateForUnmountedComponent = {}; 505 | 506 | function warnNoop(publicInstance, callerName) { 507 | { 508 | var constructor = publicInstance.constructor; 509 | var componentName = constructor && (constructor.displayName || constructor.name) || 'ReactClass'; 510 | var warningKey = componentName + '.' + callerName; 511 | if (didWarnStateUpdateForUnmountedComponent[warningKey]) { 512 | return; 513 | } 514 | warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op.\n\nPlease check the code for the %s component.', callerName, callerName, componentName); 515 | didWarnStateUpdateForUnmountedComponent[warningKey] = true; 516 | } 517 | } 518 | 519 | /** 520 | * This is the abstract API for an update queue. 521 | */ 522 | var ReactNoopUpdateQueue = { 523 | /** 524 | * Checks whether or not this composite component is mounted. 525 | * @param {ReactClass} publicInstance The instance we want to test. 526 | * @return {boolean} True if mounted, false otherwise. 527 | * @protected 528 | * @final 529 | */ 530 | isMounted: function (publicInstance) { 531 | return false; 532 | }, 533 | 534 | /** 535 | * Forces an update. This should only be invoked when it is known with 536 | * certainty that we are **not** in a DOM transaction. 537 | * 538 | * You may want to call this when you know that some deeper aspect of the 539 | * component's state has changed but `setState` was not called. 540 | * 541 | * This will not invoke `shouldComponentUpdate`, but it will invoke 542 | * `componentWillUpdate` and `componentDidUpdate`. 543 | * 544 | * @param {ReactClass} publicInstance The instance that should rerender. 545 | * @param {?function} callback Called after component is updated. 546 | * @param {?string} callerName name of the calling function in the public API. 547 | * @internal 548 | */ 549 | enqueueForceUpdate: function (publicInstance, callback, callerName) { 550 | warnNoop(publicInstance, 'forceUpdate'); 551 | }, 552 | 553 | /** 554 | * Replaces all of the state. Always use this or `setState` to mutate state. 555 | * You should treat `this.state` as immutable. 556 | * 557 | * There is no guarantee that `this.state` will be immediately updated, so 558 | * accessing `this.state` after calling this method may return the old value. 559 | * 560 | * @param {ReactClass} publicInstance The instance that should rerender. 561 | * @param {object} completeState Next state. 562 | * @param {?function} callback Called after component is updated. 563 | * @param {?string} callerName name of the calling function in the public API. 564 | * @internal 565 | */ 566 | enqueueReplaceState: function (publicInstance, completeState, callback, callerName) { 567 | warnNoop(publicInstance, 'replaceState'); 568 | }, 569 | 570 | /** 571 | * Sets a subset of the state. This only exists because _pendingState is 572 | * internal. This provides a merging strategy that is not available to deep 573 | * properties which is confusing. TODO: Expose pendingState or don't use it 574 | * during the merge. 575 | * 576 | * @param {ReactClass} publicInstance The instance that should rerender. 577 | * @param {object} partialState Next partial state to be merged with state. 578 | * @param {?function} callback Called after component is updated. 579 | * @param {?string} Name of the calling function in the public API. 580 | * @internal 581 | */ 582 | enqueueSetState: function (publicInstance, partialState, callback, callerName) { 583 | warnNoop(publicInstance, 'setState'); 584 | } 585 | }; 586 | 587 | /** 588 | * Base class helpers for the updating state of a component. 589 | */ 590 | function Component(props, context, updater) { 591 | this.props = props; 592 | this.context = context; 593 | this.refs = emptyObject; 594 | // We initialize the default updater but the real one gets injected by the 595 | // renderer. 596 | this.updater = updater || ReactNoopUpdateQueue; 597 | } 598 | 599 | Component.prototype.isReactComponent = {}; 600 | 601 | /** 602 | * Sets a subset of the state. Always use this to mutate 603 | * state. You should treat `this.state` as immutable. 604 | * 605 | * There is no guarantee that `this.state` will be immediately updated, so 606 | * accessing `this.state` after calling this method may return the old value. 607 | * 608 | * There is no guarantee that calls to `setState` will run synchronously, 609 | * as they may eventually be batched together. You can provide an optional 610 | * callback that will be executed when the call to setState is actually 611 | * completed. 612 | * 613 | * When a function is provided to setState, it will be called at some point in 614 | * the future (not synchronously). It will be called with the up to date 615 | * component arguments (state, props, context). These values can be different 616 | * from this.* because your function may be called after receiveProps but before 617 | * shouldComponentUpdate, and this new state, props, and context will not yet be 618 | * assigned to this. 619 | * 620 | * @param {object|function} partialState Next partial state or function to 621 | * produce next partial state to be merged with current state. 622 | * @param {?function} callback Called after state is updated. 623 | * @final 624 | * @protected 625 | */ 626 | Component.prototype.setState = function (partialState, callback) { 627 | !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0; 628 | this.updater.enqueueSetState(this, partialState, callback, 'setState'); 629 | }; 630 | 631 | /** 632 | * Forces an update. This should only be invoked when it is known with 633 | * certainty that we are **not** in a DOM transaction. 634 | * 635 | * You may want to call this when you know that some deeper aspect of the 636 | * component's state has changed but `setState` was not called. 637 | * 638 | * This will not invoke `shouldComponentUpdate`, but it will invoke 639 | * `componentWillUpdate` and `componentDidUpdate`. 640 | * 641 | * @param {?function} callback Called after update is complete. 642 | * @final 643 | * @protected 644 | */ 645 | Component.prototype.forceUpdate = function (callback) { 646 | this.updater.enqueueForceUpdate(this, callback, 'forceUpdate'); 647 | }; 648 | 649 | /** 650 | * Deprecated APIs. These APIs used to exist on classic React classes but since 651 | * we would like to deprecate them, we're not going to move them over to this 652 | * modern base class. Instead, we define a getter that warns if it's accessed. 653 | */ 654 | { 655 | var deprecatedAPIs = { 656 | isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'], 657 | replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'] 658 | }; 659 | var defineDeprecationWarning = function (methodName, info) { 660 | Object.defineProperty(Component.prototype, methodName, { 661 | get: function () { 662 | lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]); 663 | return undefined; 664 | } 665 | }); 666 | }; 667 | for (var fnName in deprecatedAPIs) { 668 | if (deprecatedAPIs.hasOwnProperty(fnName)) { 669 | defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); 670 | } 671 | } 672 | } 673 | 674 | /** 675 | * Base class helpers for the updating state of a component. 676 | */ 677 | function PureComponent(props, context, updater) { 678 | // Duplicated from Component. 679 | this.props = props; 680 | this.context = context; 681 | this.refs = emptyObject; 682 | // We initialize the default updater but the real one gets injected by the 683 | // renderer. 684 | this.updater = updater || ReactNoopUpdateQueue; 685 | } 686 | 687 | function ComponentDummy() {} 688 | ComponentDummy.prototype = Component.prototype; 689 | var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); 690 | pureComponentPrototype.constructor = PureComponent; 691 | // Avoid an extra prototype jump for these methods. 692 | _assign(pureComponentPrototype, Component.prototype); 693 | pureComponentPrototype.isPureReactComponent = true; 694 | 695 | function AsyncComponent(props, context, updater) { 696 | // Duplicated from Component. 697 | this.props = props; 698 | this.context = context; 699 | this.refs = emptyObject; 700 | // We initialize the default updater but the real one gets injected by the 701 | // renderer. 702 | this.updater = updater || ReactNoopUpdateQueue; 703 | } 704 | 705 | var asyncComponentPrototype = AsyncComponent.prototype = new ComponentDummy(); 706 | asyncComponentPrototype.constructor = AsyncComponent; 707 | // Avoid an extra prototype jump for these methods. 708 | _assign(asyncComponentPrototype, Component.prototype); 709 | asyncComponentPrototype.unstable_isAsyncReactComponent = true; 710 | asyncComponentPrototype.render = function () { 711 | return this.props.children; 712 | }; 713 | 714 | /** 715 | * Keeps track of the current owner. 716 | * 717 | * The current owner is the component who should own any components that are 718 | * currently being constructed. 719 | */ 720 | var ReactCurrentOwner = { 721 | /** 722 | * @internal 723 | * @type {ReactComponent} 724 | */ 725 | current: null 726 | }; 727 | 728 | var hasOwnProperty = Object.prototype.hasOwnProperty; 729 | 730 | var RESERVED_PROPS = { 731 | key: true, 732 | ref: true, 733 | __self: true, 734 | __source: true 735 | }; 736 | 737 | var specialPropKeyWarningShown; 738 | var specialPropRefWarningShown; 739 | 740 | function hasValidRef(config) { 741 | { 742 | if (hasOwnProperty.call(config, 'ref')) { 743 | var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; 744 | if (getter && getter.isReactWarning) { 745 | return false; 746 | } 747 | } 748 | } 749 | return config.ref !== undefined; 750 | } 751 | 752 | function hasValidKey(config) { 753 | { 754 | if (hasOwnProperty.call(config, 'key')) { 755 | var getter = Object.getOwnPropertyDescriptor(config, 'key').get; 756 | if (getter && getter.isReactWarning) { 757 | return false; 758 | } 759 | } 760 | } 761 | return config.key !== undefined; 762 | } 763 | 764 | function defineKeyPropWarningGetter(props, displayName) { 765 | var warnAboutAccessingKey = function () { 766 | if (!specialPropKeyWarningShown) { 767 | specialPropKeyWarningShown = true; 768 | warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName); 769 | } 770 | }; 771 | warnAboutAccessingKey.isReactWarning = true; 772 | Object.defineProperty(props, 'key', { 773 | get: warnAboutAccessingKey, 774 | configurable: true 775 | }); 776 | } 777 | 778 | function defineRefPropWarningGetter(props, displayName) { 779 | var warnAboutAccessingRef = function () { 780 | if (!specialPropRefWarningShown) { 781 | specialPropRefWarningShown = true; 782 | warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName); 783 | } 784 | }; 785 | warnAboutAccessingRef.isReactWarning = true; 786 | Object.defineProperty(props, 'ref', { 787 | get: warnAboutAccessingRef, 788 | configurable: true 789 | }); 790 | } 791 | 792 | /** 793 | * Factory method to create a new React element. This no longer adheres to 794 | * the class pattern, so do not use new to call it. Also, no instanceof check 795 | * will work. Instead test $$typeof field against Symbol.for('react.element') to check 796 | * if something is a React Element. 797 | * 798 | * @param {*} type 799 | * @param {*} key 800 | * @param {string|object} ref 801 | * @param {*} self A *temporary* helper to detect places where `this` is 802 | * different from the `owner` when React.createElement is called, so that we 803 | * can warn. We want to get rid of owner and replace string `ref`s with arrow 804 | * functions, and as long as `this` and owner are the same, there will be no 805 | * change in behavior. 806 | * @param {*} source An annotation object (added by a transpiler or otherwise) 807 | * indicating filename, line number, and/or other information. 808 | * @param {*} owner 809 | * @param {*} props 810 | * @internal 811 | */ 812 | var ReactElement = function (type, key, ref, self, source, owner, props) { 813 | var element = { 814 | // This tag allow us to uniquely identify this as a React Element 815 | $$typeof: REACT_ELEMENT_TYPE, 816 | 817 | // Built-in properties that belong on the element 818 | type: type, 819 | key: key, 820 | ref: ref, 821 | props: props, 822 | 823 | // Record the component responsible for creating this element. 824 | _owner: owner 825 | }; 826 | 827 | { 828 | // The validation flag is currently mutative. We put it on 829 | // an external backing store so that we can freeze the whole object. 830 | // This can be replaced with a WeakMap once they are implemented in 831 | // commonly used development environments. 832 | element._store = {}; 833 | 834 | // To make comparing ReactElements easier for testing purposes, we make 835 | // the validation flag non-enumerable (where possible, which should 836 | // include every environment we run tests in), so the test framework 837 | // ignores it. 838 | Object.defineProperty(element._store, 'validated', { 839 | configurable: false, 840 | enumerable: false, 841 | writable: true, 842 | value: false 843 | }); 844 | // self and source are DEV only properties. 845 | Object.defineProperty(element, '_self', { 846 | configurable: false, 847 | enumerable: false, 848 | writable: false, 849 | value: self 850 | }); 851 | // Two elements created in two different places should be considered 852 | // equal for testing purposes and therefore we hide it from enumeration. 853 | Object.defineProperty(element, '_source', { 854 | configurable: false, 855 | enumerable: false, 856 | writable: false, 857 | value: source 858 | }); 859 | if (Object.freeze) { 860 | Object.freeze(element.props); 861 | Object.freeze(element); 862 | } 863 | } 864 | 865 | return element; 866 | }; 867 | 868 | /** 869 | * Create and return a new ReactElement of the given type. 870 | * See https://reactjs.org/docs/react-api.html#createelement 871 | */ 872 | function createElement(type, config, children) { 873 | var propName; 874 | 875 | // Reserved names are extracted 876 | var props = {}; 877 | 878 | var key = null; 879 | var ref = null; 880 | var self = null; 881 | var source = null; 882 | 883 | if (config != null) { 884 | if (hasValidRef(config)) { 885 | ref = config.ref; 886 | } 887 | if (hasValidKey(config)) { 888 | key = '' + config.key; 889 | } 890 | 891 | self = config.__self === undefined ? null : config.__self; 892 | source = config.__source === undefined ? null : config.__source; 893 | // Remaining properties are added to a new props object 894 | for (propName in config) { 895 | if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { 896 | props[propName] = config[propName]; 897 | } 898 | } 899 | } 900 | 901 | // Children can be more than one argument, and those are transferred onto 902 | // the newly allocated props object. 903 | var childrenLength = arguments.length - 2; 904 | if (childrenLength === 1) { 905 | props.children = children; 906 | } else if (childrenLength > 1) { 907 | var childArray = Array(childrenLength); 908 | for (var i = 0; i < childrenLength; i++) { 909 | childArray[i] = arguments[i + 2]; 910 | } 911 | { 912 | if (Object.freeze) { 913 | Object.freeze(childArray); 914 | } 915 | } 916 | props.children = childArray; 917 | } 918 | 919 | // Resolve default props 920 | if (type && type.defaultProps) { 921 | var defaultProps = type.defaultProps; 922 | for (propName in defaultProps) { 923 | if (props[propName] === undefined) { 924 | props[propName] = defaultProps[propName]; 925 | } 926 | } 927 | } 928 | { 929 | if (key || ref) { 930 | if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) { 931 | var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; 932 | if (key) { 933 | defineKeyPropWarningGetter(props, displayName); 934 | } 935 | if (ref) { 936 | defineRefPropWarningGetter(props, displayName); 937 | } 938 | } 939 | } 940 | } 941 | return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); 942 | } 943 | 944 | /** 945 | * Return a function that produces ReactElements of a given type. 946 | * See https://reactjs.org/docs/react-api.html#createfactory 947 | */ 948 | 949 | function cloneAndReplaceKey(oldElement, newKey) { 950 | var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); 951 | 952 | return newElement; 953 | } 954 | 955 | /** 956 | * Clone and return a new ReactElement using element as the starting point. 957 | * See https://reactjs.org/docs/react-api.html#cloneelement 958 | */ 959 | function cloneElement(element, config, children) { 960 | var propName; 961 | 962 | // Original props are copied 963 | var props = _assign({}, element.props); 964 | 965 | // Reserved names are extracted 966 | var key = element.key; 967 | var ref = element.ref; 968 | // Self is preserved since the owner is preserved. 969 | var self = element._self; 970 | // Source is preserved since cloneElement is unlikely to be targeted by a 971 | // transpiler, and the original source is probably a better indicator of the 972 | // true owner. 973 | var source = element._source; 974 | 975 | // Owner will be preserved, unless ref is overridden 976 | var owner = element._owner; 977 | 978 | if (config != null) { 979 | if (hasValidRef(config)) { 980 | // Silently steal the ref from the parent. 981 | ref = config.ref; 982 | owner = ReactCurrentOwner.current; 983 | } 984 | if (hasValidKey(config)) { 985 | key = '' + config.key; 986 | } 987 | 988 | // Remaining properties override existing props 989 | var defaultProps; 990 | if (element.type && element.type.defaultProps) { 991 | defaultProps = element.type.defaultProps; 992 | } 993 | for (propName in config) { 994 | if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { 995 | if (config[propName] === undefined && defaultProps !== undefined) { 996 | // Resolve default props 997 | props[propName] = defaultProps[propName]; 998 | } else { 999 | props[propName] = config[propName]; 1000 | } 1001 | } 1002 | } 1003 | } 1004 | 1005 | // Children can be more than one argument, and those are transferred onto 1006 | // the newly allocated props object. 1007 | var childrenLength = arguments.length - 2; 1008 | if (childrenLength === 1) { 1009 | props.children = children; 1010 | } else if (childrenLength > 1) { 1011 | var childArray = Array(childrenLength); 1012 | for (var i = 0; i < childrenLength; i++) { 1013 | childArray[i] = arguments[i + 2]; 1014 | } 1015 | props.children = childArray; 1016 | } 1017 | 1018 | return ReactElement(element.type, key, ref, self, source, owner, props); 1019 | } 1020 | 1021 | /** 1022 | * Verifies the object is a ReactElement. 1023 | * See https://reactjs.org/docs/react-api.html#isvalidelement 1024 | * @param {?object} object 1025 | * @return {boolean} True if `object` is a valid component. 1026 | * @final 1027 | */ 1028 | function isValidElement(object) { 1029 | return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; 1030 | } 1031 | 1032 | var ReactDebugCurrentFrame = {}; 1033 | 1034 | { 1035 | // Component that is being worked on 1036 | ReactDebugCurrentFrame.getCurrentStack = null; 1037 | 1038 | ReactDebugCurrentFrame.getStackAddendum = function () { 1039 | var impl = ReactDebugCurrentFrame.getCurrentStack; 1040 | if (impl) { 1041 | return impl(); 1042 | } 1043 | return null; 1044 | }; 1045 | } 1046 | 1047 | var SEPARATOR = '.'; 1048 | var SUBSEPARATOR = ':'; 1049 | 1050 | /** 1051 | * Escape and wrap key so it is safe to use as a reactid 1052 | * 1053 | * @param {string} key to be escaped. 1054 | * @return {string} the escaped key. 1055 | */ 1056 | function escape(key) { 1057 | var escapeRegex = /[=:]/g; 1058 | var escaperLookup = { 1059 | '=': '=0', 1060 | ':': '=2' 1061 | }; 1062 | var escapedString = ('' + key).replace(escapeRegex, function (match) { 1063 | return escaperLookup[match]; 1064 | }); 1065 | 1066 | return '$' + escapedString; 1067 | } 1068 | 1069 | /** 1070 | * TODO: Test that a single child and an array with one item have the same key 1071 | * pattern. 1072 | */ 1073 | 1074 | var didWarnAboutMaps = false; 1075 | 1076 | var userProvidedKeyEscapeRegex = /\/+/g; 1077 | function escapeUserProvidedKey(text) { 1078 | return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/'); 1079 | } 1080 | 1081 | var POOL_SIZE = 10; 1082 | var traverseContextPool = []; 1083 | function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) { 1084 | if (traverseContextPool.length) { 1085 | var traverseContext = traverseContextPool.pop(); 1086 | traverseContext.result = mapResult; 1087 | traverseContext.keyPrefix = keyPrefix; 1088 | traverseContext.func = mapFunction; 1089 | traverseContext.context = mapContext; 1090 | traverseContext.count = 0; 1091 | return traverseContext; 1092 | } else { 1093 | return { 1094 | result: mapResult, 1095 | keyPrefix: keyPrefix, 1096 | func: mapFunction, 1097 | context: mapContext, 1098 | count: 0 1099 | }; 1100 | } 1101 | } 1102 | 1103 | function releaseTraverseContext(traverseContext) { 1104 | traverseContext.result = null; 1105 | traverseContext.keyPrefix = null; 1106 | traverseContext.func = null; 1107 | traverseContext.context = null; 1108 | traverseContext.count = 0; 1109 | if (traverseContextPool.length < POOL_SIZE) { 1110 | traverseContextPool.push(traverseContext); 1111 | } 1112 | } 1113 | 1114 | /** 1115 | * @param {?*} children Children tree container. 1116 | * @param {!string} nameSoFar Name of the key path so far. 1117 | * @param {!function} callback Callback to invoke with each child found. 1118 | * @param {?*} traverseContext Used to pass information throughout the traversal 1119 | * process. 1120 | * @return {!number} The number of children in this subtree. 1121 | */ 1122 | function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) { 1123 | var type = typeof children; 1124 | 1125 | if (type === 'undefined' || type === 'boolean') { 1126 | // All of the above are perceived as null. 1127 | children = null; 1128 | } 1129 | 1130 | var invokeCallback = false; 1131 | 1132 | if (children === null) { 1133 | invokeCallback = true; 1134 | } else { 1135 | switch (type) { 1136 | case 'string': 1137 | case 'number': 1138 | invokeCallback = true; 1139 | break; 1140 | case 'object': 1141 | switch (children.$$typeof) { 1142 | case REACT_ELEMENT_TYPE: 1143 | case REACT_CALL_TYPE: 1144 | case REACT_RETURN_TYPE: 1145 | case REACT_PORTAL_TYPE: 1146 | invokeCallback = true; 1147 | } 1148 | } 1149 | } 1150 | 1151 | if (invokeCallback) { 1152 | callback(traverseContext, children, 1153 | // If it's the only child, treat the name as if it was wrapped in an array 1154 | // so that it's consistent if the number of children grows. 1155 | nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar); 1156 | return 1; 1157 | } 1158 | 1159 | var child; 1160 | var nextName; 1161 | var subtreeCount = 0; // Count of children found in the current subtree. 1162 | var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR; 1163 | 1164 | if (Array.isArray(children)) { 1165 | for (var i = 0; i < children.length; i++) { 1166 | child = children[i]; 1167 | nextName = nextNamePrefix + getComponentKey(child, i); 1168 | subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); 1169 | } 1170 | } else { 1171 | var iteratorFn = getIteratorFn(children); 1172 | if (typeof iteratorFn === 'function') { 1173 | { 1174 | // Warn about using Maps as children 1175 | if (iteratorFn === children.entries) { 1176 | warning(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum()); 1177 | didWarnAboutMaps = true; 1178 | } 1179 | } 1180 | 1181 | var iterator = iteratorFn.call(children); 1182 | var step; 1183 | var ii = 0; 1184 | while (!(step = iterator.next()).done) { 1185 | child = step.value; 1186 | nextName = nextNamePrefix + getComponentKey(child, ii++); 1187 | subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); 1188 | } 1189 | } else if (type === 'object') { 1190 | var addendum = ''; 1191 | { 1192 | addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum(); 1193 | } 1194 | var childrenString = '' + children; 1195 | invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum); 1196 | } 1197 | } 1198 | 1199 | return subtreeCount; 1200 | } 1201 | 1202 | /** 1203 | * Traverses children that are typically specified as `props.children`, but 1204 | * might also be specified through attributes: 1205 | * 1206 | * - `traverseAllChildren(this.props.children, ...)` 1207 | * - `traverseAllChildren(this.props.leftPanelChildren, ...)` 1208 | * 1209 | * The `traverseContext` is an optional argument that is passed through the 1210 | * entire traversal. It can be used to store accumulations or anything else that 1211 | * the callback might find relevant. 1212 | * 1213 | * @param {?*} children Children tree object. 1214 | * @param {!function} callback To invoke upon traversing each child. 1215 | * @param {?*} traverseContext Context for traversal. 1216 | * @return {!number} The number of children in this subtree. 1217 | */ 1218 | function traverseAllChildren(children, callback, traverseContext) { 1219 | if (children == null) { 1220 | return 0; 1221 | } 1222 | 1223 | return traverseAllChildrenImpl(children, '', callback, traverseContext); 1224 | } 1225 | 1226 | /** 1227 | * Generate a key string that identifies a component within a set. 1228 | * 1229 | * @param {*} component A component that could contain a manual key. 1230 | * @param {number} index Index that is used if a manual key is not provided. 1231 | * @return {string} 1232 | */ 1233 | function getComponentKey(component, index) { 1234 | // Do some typechecking here since we call this blindly. We want to ensure 1235 | // that we don't block potential future ES APIs. 1236 | if (typeof component === 'object' && component !== null && component.key != null) { 1237 | // Explicit key 1238 | return escape(component.key); 1239 | } 1240 | // Implicit key determined by the index in the set 1241 | return index.toString(36); 1242 | } 1243 | 1244 | function forEachSingleChild(bookKeeping, child, name) { 1245 | var func = bookKeeping.func, 1246 | context = bookKeeping.context; 1247 | 1248 | func.call(context, child, bookKeeping.count++); 1249 | } 1250 | 1251 | /** 1252 | * Iterates through children that are typically specified as `props.children`. 1253 | * 1254 | * See https://reactjs.org/docs/react-api.html#react.children.foreach 1255 | * 1256 | * The provided forEachFunc(child, index) will be called for each 1257 | * leaf child. 1258 | * 1259 | * @param {?*} children Children tree container. 1260 | * @param {function(*, int)} forEachFunc 1261 | * @param {*} forEachContext Context for forEachContext. 1262 | */ 1263 | function forEachChildren(children, forEachFunc, forEachContext) { 1264 | if (children == null) { 1265 | return children; 1266 | } 1267 | var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext); 1268 | traverseAllChildren(children, forEachSingleChild, traverseContext); 1269 | releaseTraverseContext(traverseContext); 1270 | } 1271 | 1272 | function mapSingleChildIntoContext(bookKeeping, child, childKey) { 1273 | var result = bookKeeping.result, 1274 | keyPrefix = bookKeeping.keyPrefix, 1275 | func = bookKeeping.func, 1276 | context = bookKeeping.context; 1277 | 1278 | var mappedChild = func.call(context, child, bookKeeping.count++); 1279 | if (Array.isArray(mappedChild)) { 1280 | mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument); 1281 | } else if (mappedChild != null) { 1282 | if (isValidElement(mappedChild)) { 1283 | mappedChild = cloneAndReplaceKey(mappedChild, 1284 | // Keep both the (mapped) and old keys if they differ, just as 1285 | // traverseAllChildren used to do for objects as children 1286 | keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey); 1287 | } 1288 | result.push(mappedChild); 1289 | } 1290 | } 1291 | 1292 | function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) { 1293 | var escapedPrefix = ''; 1294 | if (prefix != null) { 1295 | escapedPrefix = escapeUserProvidedKey(prefix) + '/'; 1296 | } 1297 | var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context); 1298 | traverseAllChildren(children, mapSingleChildIntoContext, traverseContext); 1299 | releaseTraverseContext(traverseContext); 1300 | } 1301 | 1302 | /** 1303 | * Maps children that are typically specified as `props.children`. 1304 | * 1305 | * See https://reactjs.org/docs/react-api.html#react.children.map 1306 | * 1307 | * The provided mapFunction(child, key, index) will be called for each 1308 | * leaf child. 1309 | * 1310 | * @param {?*} children Children tree container. 1311 | * @param {function(*, int)} func The map function. 1312 | * @param {*} context Context for mapFunction. 1313 | * @return {object} Object containing the ordered map of results. 1314 | */ 1315 | function mapChildren(children, func, context) { 1316 | if (children == null) { 1317 | return children; 1318 | } 1319 | var result = []; 1320 | mapIntoWithKeyPrefixInternal(children, result, null, func, context); 1321 | return result; 1322 | } 1323 | 1324 | /** 1325 | * Count the number of children that are typically specified as 1326 | * `props.children`. 1327 | * 1328 | * See https://reactjs.org/docs/react-api.html#react.children.count 1329 | * 1330 | * @param {?*} children Children tree container. 1331 | * @return {number} The number of children. 1332 | */ 1333 | function countChildren(children, context) { 1334 | return traverseAllChildren(children, emptyFunction.thatReturnsNull, null); 1335 | } 1336 | 1337 | /** 1338 | * Flatten a children object (typically specified as `props.children`) and 1339 | * return an array with appropriately re-keyed children. 1340 | * 1341 | * See https://reactjs.org/docs/react-api.html#react.children.toarray 1342 | */ 1343 | function toArray(children) { 1344 | var result = []; 1345 | mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument); 1346 | return result; 1347 | } 1348 | 1349 | /** 1350 | * Returns the first child in a collection of children and verifies that there 1351 | * is only one child in the collection. 1352 | * 1353 | * See https://reactjs.org/docs/react-api.html#react.children.only 1354 | * 1355 | * The current implementation of this function assumes that a single child gets 1356 | * passed without a wrapper, but the purpose of this helper function is to 1357 | * abstract away the particular structure of children. 1358 | * 1359 | * @param {?object} children Child collection structure. 1360 | * @return {ReactElement} The first and only `ReactElement` contained in the 1361 | * structure. 1362 | */ 1363 | function onlyChild(children) { 1364 | !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0; 1365 | return children; 1366 | } 1367 | 1368 | var describeComponentFrame = function (name, source, ownerName) { 1369 | return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : ''); 1370 | }; 1371 | 1372 | function getComponentName(fiber) { 1373 | var type = fiber.type; 1374 | 1375 | if (typeof type === 'string') { 1376 | return type; 1377 | } 1378 | if (typeof type === 'function') { 1379 | return type.displayName || type.name; 1380 | } 1381 | return null; 1382 | } 1383 | 1384 | /** 1385 | * ReactElementValidator provides a wrapper around a element factory 1386 | * which validates the props passed to the element. This is intended to be 1387 | * used only in DEV and could be replaced by a static type checker for languages 1388 | * that support it. 1389 | */ 1390 | 1391 | { 1392 | var currentlyValidatingElement = null; 1393 | 1394 | var propTypesMisspellWarningShown = false; 1395 | 1396 | var getDisplayName = function (element) { 1397 | if (element == null) { 1398 | return '#empty'; 1399 | } else if (typeof element === 'string' || typeof element === 'number') { 1400 | return '#text'; 1401 | } else if (typeof element.type === 'string') { 1402 | return element.type; 1403 | } else if (element.type === REACT_FRAGMENT_TYPE) { 1404 | return 'React.Fragment'; 1405 | } else { 1406 | return element.type.displayName || element.type.name || 'Unknown'; 1407 | } 1408 | }; 1409 | 1410 | var getStackAddendum = function () { 1411 | var stack = ''; 1412 | if (currentlyValidatingElement) { 1413 | var name = getDisplayName(currentlyValidatingElement); 1414 | var owner = currentlyValidatingElement._owner; 1415 | stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner)); 1416 | } 1417 | stack += ReactDebugCurrentFrame.getStackAddendum() || ''; 1418 | return stack; 1419 | }; 1420 | 1421 | var VALID_FRAGMENT_PROPS = new Map([['children', true], ['key', true]]); 1422 | } 1423 | 1424 | function getDeclarationErrorAddendum() { 1425 | if (ReactCurrentOwner.current) { 1426 | var name = getComponentName(ReactCurrentOwner.current); 1427 | if (name) { 1428 | return '\n\nCheck the render method of `' + name + '`.'; 1429 | } 1430 | } 1431 | return ''; 1432 | } 1433 | 1434 | function getSourceInfoErrorAddendum(elementProps) { 1435 | if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) { 1436 | var source = elementProps.__source; 1437 | var fileName = source.fileName.replace(/^.*[\\\/]/, ''); 1438 | var lineNumber = source.lineNumber; 1439 | return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; 1440 | } 1441 | return ''; 1442 | } 1443 | 1444 | /** 1445 | * Warn if there's no key explicitly set on dynamic arrays of children or 1446 | * object keys are not valid. This allows us to keep track of children between 1447 | * updates. 1448 | */ 1449 | var ownerHasKeyUseWarning = {}; 1450 | 1451 | function getCurrentComponentErrorInfo(parentType) { 1452 | var info = getDeclarationErrorAddendum(); 1453 | 1454 | if (!info) { 1455 | var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; 1456 | if (parentName) { 1457 | info = '\n\nCheck the top-level render call using <' + parentName + '>.'; 1458 | } 1459 | } 1460 | return info; 1461 | } 1462 | 1463 | /** 1464 | * Warn if the element doesn't have an explicit key assigned to it. 1465 | * This element is in an array. The array could grow and shrink or be 1466 | * reordered. All children that haven't already been validated are required to 1467 | * have a "key" property assigned to it. Error statuses are cached so a warning 1468 | * will only be shown once. 1469 | * 1470 | * @internal 1471 | * @param {ReactElement} element Element that requires a key. 1472 | * @param {*} parentType element's parent's type. 1473 | */ 1474 | function validateExplicitKey(element, parentType) { 1475 | if (!element._store || element._store.validated || element.key != null) { 1476 | return; 1477 | } 1478 | element._store.validated = true; 1479 | 1480 | var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); 1481 | if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { 1482 | return; 1483 | } 1484 | ownerHasKeyUseWarning[currentComponentErrorInfo] = true; 1485 | 1486 | // Usually the current owner is the offender, but if it accepts children as a 1487 | // property, it may be the creator of the child that's responsible for 1488 | // assigning it a key. 1489 | var childOwner = ''; 1490 | if (element && element._owner && element._owner !== ReactCurrentOwner.current) { 1491 | // Give the component that originally created this child. 1492 | childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.'; 1493 | } 1494 | 1495 | currentlyValidatingElement = element; 1496 | { 1497 | warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum()); 1498 | } 1499 | currentlyValidatingElement = null; 1500 | } 1501 | 1502 | /** 1503 | * Ensure that every element either is passed in a static location, in an 1504 | * array with an explicit keys property defined, or in an object literal 1505 | * with valid key property. 1506 | * 1507 | * @internal 1508 | * @param {ReactNode} node Statically passed child of any type. 1509 | * @param {*} parentType node's parent's type. 1510 | */ 1511 | function validateChildKeys(node, parentType) { 1512 | if (typeof node !== 'object') { 1513 | return; 1514 | } 1515 | if (Array.isArray(node)) { 1516 | for (var i = 0; i < node.length; i++) { 1517 | var child = node[i]; 1518 | if (isValidElement(child)) { 1519 | validateExplicitKey(child, parentType); 1520 | } 1521 | } 1522 | } else if (isValidElement(node)) { 1523 | // This element was passed in a valid location. 1524 | if (node._store) { 1525 | node._store.validated = true; 1526 | } 1527 | } else if (node) { 1528 | var iteratorFn = getIteratorFn(node); 1529 | if (typeof iteratorFn === 'function') { 1530 | // Entry iterators used to provide implicit keys, 1531 | // but now we print a separate warning for them later. 1532 | if (iteratorFn !== node.entries) { 1533 | var iterator = iteratorFn.call(node); 1534 | var step; 1535 | while (!(step = iterator.next()).done) { 1536 | if (isValidElement(step.value)) { 1537 | validateExplicitKey(step.value, parentType); 1538 | } 1539 | } 1540 | } 1541 | } 1542 | } 1543 | } 1544 | 1545 | /** 1546 | * Given an element, validate that its props follow the propTypes definition, 1547 | * provided by the type. 1548 | * 1549 | * @param {ReactElement} element 1550 | */ 1551 | function validatePropTypes(element) { 1552 | var componentClass = element.type; 1553 | if (typeof componentClass !== 'function') { 1554 | return; 1555 | } 1556 | var name = componentClass.displayName || componentClass.name; 1557 | var propTypes = componentClass.propTypes; 1558 | if (propTypes) { 1559 | currentlyValidatingElement = element; 1560 | checkPropTypes(propTypes, element.props, 'prop', name, getStackAddendum); 1561 | currentlyValidatingElement = null; 1562 | } else if (componentClass.PropTypes !== undefined && !propTypesMisspellWarningShown) { 1563 | propTypesMisspellWarningShown = true; 1564 | warning(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown'); 1565 | } 1566 | if (typeof componentClass.getDefaultProps === 'function') { 1567 | warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); 1568 | } 1569 | } 1570 | 1571 | /** 1572 | * Given a fragment, validate that it can only be provided with fragment props 1573 | * @param {ReactElement} fragment 1574 | */ 1575 | function validateFragmentProps(fragment) { 1576 | currentlyValidatingElement = fragment; 1577 | 1578 | var _iteratorNormalCompletion = true; 1579 | var _didIteratorError = false; 1580 | var _iteratorError = undefined; 1581 | 1582 | try { 1583 | for (var _iterator = Object.keys(fragment.props)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { 1584 | var key = _step.value; 1585 | 1586 | if (!VALID_FRAGMENT_PROPS.has(key)) { 1587 | warning(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum()); 1588 | break; 1589 | } 1590 | } 1591 | } catch (err) { 1592 | _didIteratorError = true; 1593 | _iteratorError = err; 1594 | } finally { 1595 | try { 1596 | if (!_iteratorNormalCompletion && _iterator['return']) { 1597 | _iterator['return'](); 1598 | } 1599 | } finally { 1600 | if (_didIteratorError) { 1601 | throw _iteratorError; 1602 | } 1603 | } 1604 | } 1605 | 1606 | if (fragment.ref !== null) { 1607 | warning(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum()); 1608 | } 1609 | 1610 | currentlyValidatingElement = null; 1611 | } 1612 | 1613 | function createElementWithValidation(type, props, children) { 1614 | var validType = typeof type === 'string' || typeof type === 'function' || typeof type === 'symbol' || typeof type === 'number'; 1615 | // We warn in this case but don't throw. We expect the element creation to 1616 | // succeed and there will likely be errors in render. 1617 | if (!validType) { 1618 | var info = ''; 1619 | if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { 1620 | info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports."; 1621 | } 1622 | 1623 | var sourceInfo = getSourceInfoErrorAddendum(props); 1624 | if (sourceInfo) { 1625 | info += sourceInfo; 1626 | } else { 1627 | info += getDeclarationErrorAddendum(); 1628 | } 1629 | 1630 | info += getStackAddendum() || ''; 1631 | 1632 | warning(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', type == null ? type : typeof type, info); 1633 | } 1634 | 1635 | var element = createElement.apply(this, arguments); 1636 | 1637 | // The result can be nullish if a mock or a custom function is used. 1638 | // TODO: Drop this when these are no longer allowed as the type argument. 1639 | if (element == null) { 1640 | return element; 1641 | } 1642 | 1643 | // Skip key warning if the type isn't valid since our key validation logic 1644 | // doesn't expect a non-string/function type and can throw confusing errors. 1645 | // We don't want exception behavior to differ between dev and prod. 1646 | // (Rendering will throw with a helpful message and as soon as the type is 1647 | // fixed, the key warnings will appear.) 1648 | if (validType) { 1649 | for (var i = 2; i < arguments.length; i++) { 1650 | validateChildKeys(arguments[i], type); 1651 | } 1652 | } 1653 | 1654 | if (typeof type === 'symbol' && type === REACT_FRAGMENT_TYPE) { 1655 | validateFragmentProps(element); 1656 | } else { 1657 | validatePropTypes(element); 1658 | } 1659 | 1660 | return element; 1661 | } 1662 | 1663 | function createFactoryWithValidation(type) { 1664 | var validatedFactory = createElementWithValidation.bind(null, type); 1665 | // Legacy hook TODO: Warn if this is accessed 1666 | validatedFactory.type = type; 1667 | 1668 | { 1669 | Object.defineProperty(validatedFactory, 'type', { 1670 | enumerable: false, 1671 | get: function () { 1672 | lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.'); 1673 | Object.defineProperty(this, 'type', { 1674 | value: type 1675 | }); 1676 | return type; 1677 | } 1678 | }); 1679 | } 1680 | 1681 | return validatedFactory; 1682 | } 1683 | 1684 | function cloneElementWithValidation(element, props, children) { 1685 | var newElement = cloneElement.apply(this, arguments); 1686 | for (var i = 2; i < arguments.length; i++) { 1687 | validateChildKeys(arguments[i], newElement.type); 1688 | } 1689 | validatePropTypes(newElement); 1690 | return newElement; 1691 | } 1692 | 1693 | var React = { 1694 | Children: { 1695 | map: mapChildren, 1696 | forEach: forEachChildren, 1697 | count: countChildren, 1698 | toArray: toArray, 1699 | only: onlyChild 1700 | }, 1701 | 1702 | Component: Component, 1703 | PureComponent: PureComponent, 1704 | unstable_AsyncComponent: AsyncComponent, 1705 | 1706 | Fragment: REACT_FRAGMENT_TYPE, 1707 | 1708 | createElement: createElementWithValidation, 1709 | cloneElement: cloneElementWithValidation, 1710 | createFactory: createFactoryWithValidation, 1711 | isValidElement: isValidElement, 1712 | 1713 | version: ReactVersion, 1714 | 1715 | __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { 1716 | ReactCurrentOwner: ReactCurrentOwner, 1717 | // Used by renderers to avoid bundling object-assign twice in UMD bundles: 1718 | assign: _assign 1719 | } 1720 | }; 1721 | 1722 | { 1723 | _assign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, { 1724 | // These should not be included in production. 1725 | ReactDebugCurrentFrame: ReactDebugCurrentFrame, 1726 | // Shim for React DOM 16.0.0 which still destructured (but not used) this. 1727 | // TODO: remove in React 17.0. 1728 | ReactComponentTreeHook: {} 1729 | }); 1730 | } 1731 | 1732 | var React$2 = Object.freeze({ 1733 | default: React 1734 | }); 1735 | 1736 | var React$3 = React$2 && React || React$2; 1737 | 1738 | // TODO: decide on the top-level export form. 1739 | // This is hacky but makes it work with both Rollup and Jest. 1740 | var react = React$3['default'] ? React$3['default'] : React$3; 1741 | 1742 | module.exports = react; 1743 | })(); 1744 | } 1745 | }); 1746 | 1747 | var react = createCommonjsModule(function (module) { 1748 | 1749 | if (process.env.NODE_ENV === 'production') { 1750 | module.exports = react_production_min; 1751 | } else { 1752 | module.exports = react_development; 1753 | } 1754 | }); 1755 | 1756 | function mapToObject(map) { 1757 | const object = {}; 1758 | 1759 | for (const [key, value] of map.entries()) { 1760 | if (value instanceof Map) { 1761 | object[key] = mapToObject(value); 1762 | } else { 1763 | object[key] = value; 1764 | } 1765 | } 1766 | 1767 | return object; 1768 | } 1769 | 1770 | function createElement(tag, attributes, elements) { 1771 | const props = mapToObject(attributes); 1772 | return react.createElement(tag, props, ...elements); 1773 | } 1774 | 1775 | var react_index = { 1776 | createElement 1777 | }; 1778 | 1779 | export default react_index; 1780 | //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"react.js","sources":["../../node_modules/object-assign/index.js","../../node_modules/fbjs/lib/emptyObject.js","../../node_modules/fbjs/lib/emptyFunction.js","../../node_modules/react/cjs/react.production.min.js","../../node_modules/fbjs/lib/invariant.js","../../node_modules/fbjs/lib/warning.js","../../node_modules/prop-types/lib/ReactPropTypesSecret.js","../../node_modules/prop-types/checkPropTypes.js","../../node_modules/react/cjs/react.development.js","../../node_modules/react/index.js","../../src/react.index.js"],"sourcesContent":["/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar emptyObject = {};\n\nif (process.env.NODE_ENV !== 'production') {\n  Object.freeze(emptyObject);\n}\n\nmodule.exports = emptyObject;","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;","/** @license React v16.2.0\n * react.production.min.js\n *\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var m=require(\"object-assign\"),n=require(\"fbjs/lib/emptyObject\"),p=require(\"fbjs/lib/emptyFunction\"),q=\"function\"===typeof Symbol&&Symbol[\"for\"],r=q?Symbol[\"for\"](\"react.element\"):60103,t=q?Symbol[\"for\"](\"react.call\"):60104,u=q?Symbol[\"for\"](\"react.return\"):60105,v=q?Symbol[\"for\"](\"react.portal\"):60106,w=q?Symbol[\"for\"](\"react.fragment\"):60107,x=\"function\"===typeof Symbol&&Symbol.iterator;\nfunction y(a){for(var b=arguments.length-1,e=\"Minified React error #\"+a+\"; visit http://facebook.github.io/react/docs/error-decoder.html?invariant\\x3d\"+a,c=0;c<b;c++)e+=\"\\x26args[]\\x3d\"+encodeURIComponent(arguments[c+1]);b=Error(e+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\");b.name=\"Invariant Violation\";b.framesToPop=1;throw b;}\nvar z={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}};function A(a,b,e){this.props=a;this.context=b;this.refs=n;this.updater=e||z}A.prototype.isReactComponent={};A.prototype.setState=function(a,b){\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a?y(\"85\"):void 0;this.updater.enqueueSetState(this,a,b,\"setState\")};A.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};\nfunction B(a,b,e){this.props=a;this.context=b;this.refs=n;this.updater=e||z}function C(){}C.prototype=A.prototype;var D=B.prototype=new C;D.constructor=B;m(D,A.prototype);D.isPureReactComponent=!0;function E(a,b,e){this.props=a;this.context=b;this.refs=n;this.updater=e||z}var F=E.prototype=new C;F.constructor=E;m(F,A.prototype);F.unstable_isAsyncReactComponent=!0;F.render=function(){return this.props.children};var G={current:null},H=Object.prototype.hasOwnProperty,I={key:!0,ref:!0,__self:!0,__source:!0};\nfunction J(a,b,e){var c,d={},g=null,k=null;if(null!=b)for(c in void 0!==b.ref&&(k=b.ref),void 0!==b.key&&(g=\"\"+b.key),b)H.call(b,c)&&!I.hasOwnProperty(c)&&(d[c]=b[c]);var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){for(var h=Array(f),l=0;l<f;l++)h[l]=arguments[l+2];d.children=h}if(a&&a.defaultProps)for(c in f=a.defaultProps,f)void 0===d[c]&&(d[c]=f[c]);return{$$typeof:r,type:a,key:g,ref:k,props:d,_owner:G.current}}function K(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===r}\nfunction escape(a){var b={\"\\x3d\":\"\\x3d0\",\":\":\"\\x3d2\"};return\"$\"+(\"\"+a).replace(/[=:]/g,function(a){return b[a]})}var L=/\\/+/g,M=[];function N(a,b,e,c){if(M.length){var d=M.pop();d.result=a;d.keyPrefix=b;d.func=e;d.context=c;d.count=0;return d}return{result:a,keyPrefix:b,func:e,context:c,count:0}}function O(a){a.result=null;a.keyPrefix=null;a.func=null;a.context=null;a.count=0;10>M.length&&M.push(a)}\nfunction P(a,b,e,c){var d=typeof a;if(\"undefined\"===d||\"boolean\"===d)a=null;var g=!1;if(null===a)g=!0;else switch(d){case \"string\":case \"number\":g=!0;break;case \"object\":switch(a.$$typeof){case r:case t:case u:case v:g=!0}}if(g)return e(c,a,\"\"===b?\".\"+Q(a,0):b),1;g=0;b=\"\"===b?\".\":b+\":\";if(Array.isArray(a))for(var k=0;k<a.length;k++){d=a[k];var f=b+Q(d,k);g+=P(d,f,e,c)}else if(null===a||\"undefined\"===typeof a?f=null:(f=x&&a[x]||a[\"@@iterator\"],f=\"function\"===typeof f?f:null),\"function\"===typeof f)for(a=\nf.call(a),k=0;!(d=a.next()).done;)d=d.value,f=b+Q(d,k++),g+=P(d,f,e,c);else\"object\"===d&&(e=\"\"+a,y(\"31\",\"[object Object]\"===e?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":e,\"\"));return g}function Q(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(a.key):b.toString(36)}function R(a,b){a.func.call(a.context,b,a.count++)}\nfunction S(a,b,e){var c=a.result,d=a.keyPrefix;a=a.func.call(a.context,b,a.count++);Array.isArray(a)?T(a,c,e,p.thatReturnsArgument):null!=a&&(K(a)&&(b=d+(!a.key||b&&b.key===a.key?\"\":(\"\"+a.key).replace(L,\"$\\x26/\")+\"/\")+e,a={$$typeof:r,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}),c.push(a))}function T(a,b,e,c,d){var g=\"\";null!=e&&(g=(\"\"+e).replace(L,\"$\\x26/\")+\"/\");b=N(b,g,c,d);null==a||P(a,\"\",S,b);O(b)}\nvar U={Children:{map:function(a,b,e){if(null==a)return a;var c=[];T(a,c,null,b,e);return c},forEach:function(a,b,e){if(null==a)return a;b=N(null,null,b,e);null==a||P(a,\"\",R,b);O(b)},count:function(a){return null==a?0:P(a,\"\",p.thatReturnsNull,null)},toArray:function(a){var b=[];T(a,b,null,p.thatReturnsArgument);return b},only:function(a){K(a)?void 0:y(\"143\");return a}},Component:A,PureComponent:B,unstable_AsyncComponent:E,Fragment:w,createElement:J,cloneElement:function(a,b,e){var c=m({},a.props),\nd=a.key,g=a.ref,k=a._owner;if(null!=b){void 0!==b.ref&&(g=b.ref,k=G.current);void 0!==b.key&&(d=\"\"+b.key);if(a.type&&a.type.defaultProps)var f=a.type.defaultProps;for(h in b)H.call(b,h)&&!I.hasOwnProperty(h)&&(c[h]=void 0===b[h]&&void 0!==f?f[h]:b[h])}var h=arguments.length-2;if(1===h)c.children=e;else if(1<h){f=Array(h);for(var l=0;l<h;l++)f[l]=arguments[l+2];c.children=f}return{$$typeof:r,type:a.type,key:d,ref:g,props:c,_owner:k}},createFactory:function(a){var b=J.bind(null,a);b.type=a;return b},\nisValidElement:K,version:\"16.2.0\",__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED:{ReactCurrentOwner:G,assign:m}},V=Object.freeze({default:U}),W=V&&U||V;module.exports=W[\"default\"]?W[\"default\"]:W;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n}\n\nmodule.exports = invariant;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar emptyFunction = require('./emptyFunction');\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (process.env.NODE_ENV !== 'production') {\n  var printWarning = function printWarning(format) {\n    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    var argIndex = 0;\n    var message = 'Warning: ' + format.replace(/%s/g, function () {\n      return args[argIndex++];\n    });\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n\n  warning = function warning(condition, format) {\n    if (format === undefined) {\n      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n    }\n\n    if (format.indexOf('Failed Composite propType: ') === 0) {\n      return; // Ignore CompositeComponent proptype check.\n    }\n\n    if (!condition) {\n      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n        args[_key2 - 2] = arguments[_key2];\n      }\n\n      printWarning.apply(undefined, [format].concat(args));\n    }\n  };\n}\n\nmodule.exports = warning;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== 'production') {\n  var invariant = require('fbjs/lib/invariant');\n  var warning = require('fbjs/lib/warning');\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (typeSpecs.hasOwnProperty(typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');\n        }\n      }\n    }\n  }\n}\n\nmodule.exports = checkPropTypes;\n","/** @license React v16.2.0\n * react.development.js\n *\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n\n\nif (process.env.NODE_ENV !== \"production\") {\n  (function() {\n'use strict';\n\nvar _assign = require('object-assign');\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar checkPropTypes = require('prop-types/checkPropTypes');\n\n// TODO: this is special because it gets imported during build.\n\nvar ReactVersion = '16.2.0';\n\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\n// nor polyfill, then a plain number is used for performance.\nvar hasSymbol = typeof Symbol === 'function' && Symbol['for'];\n\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7;\nvar REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8;\nvar REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9;\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca;\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb;\n\nvar MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\n\nfunction getIteratorFn(maybeIterable) {\n  if (maybeIterable === null || typeof maybeIterable === 'undefined') {\n    return null;\n  }\n  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n  if (typeof maybeIterator === 'function') {\n    return maybeIterator;\n  }\n  return null;\n}\n\n/**\n * WARNING: DO NOT manually require this module.\n * This is a replacement for `invariant(...)` used by the error code system\n * and will _only_ be required by the corresponding babel pass.\n * It always throws.\n */\n\n/**\n * Forked from fbjs/warning:\n * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\n *\n * Only change is we use console.warn instead of console.error,\n * and do nothing when 'console' is not supported.\n * This really simplifies the code.\n * ---\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar lowPriorityWarning = function () {};\n\n{\n  var printWarning = function (format) {\n    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    var argIndex = 0;\n    var message = 'Warning: ' + format.replace(/%s/g, function () {\n      return args[argIndex++];\n    });\n    if (typeof console !== 'undefined') {\n      console.warn(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n\n  lowPriorityWarning = function (condition, format) {\n    if (format === undefined) {\n      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n    }\n    if (!condition) {\n      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n        args[_key2 - 2] = arguments[_key2];\n      }\n\n      printWarning.apply(undefined, [format].concat(args));\n    }\n  };\n}\n\nvar lowPriorityWarning$1 = lowPriorityWarning;\n\nvar didWarnStateUpdateForUnmountedComponent = {};\n\nfunction warnNoop(publicInstance, callerName) {\n  {\n    var constructor = publicInstance.constructor;\n    var componentName = constructor && (constructor.displayName || constructor.name) || 'ReactClass';\n    var warningKey = componentName + '.' + callerName;\n    if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\n      return;\n    }\n    warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op.\\n\\nPlease check the code for the %s component.', callerName, callerName, componentName);\n    didWarnStateUpdateForUnmountedComponent[warningKey] = true;\n  }\n}\n\n/**\n * This is the abstract API for an update queue.\n */\nvar ReactNoopUpdateQueue = {\n  /**\n   * Checks whether or not this composite component is mounted.\n   * @param {ReactClass} publicInstance The instance we want to test.\n   * @return {boolean} True if mounted, false otherwise.\n   * @protected\n   * @final\n   */\n  isMounted: function (publicInstance) {\n    return false;\n  },\n\n  /**\n   * Forces an update. This should only be invoked when it is known with\n   * certainty that we are **not** in a DOM transaction.\n   *\n   * You may want to call this when you know that some deeper aspect of the\n   * component's state has changed but `setState` was not called.\n   *\n   * This will not invoke `shouldComponentUpdate`, but it will invoke\n   * `componentWillUpdate` and `componentDidUpdate`.\n   *\n   * @param {ReactClass} publicInstance The instance that should rerender.\n   * @param {?function} callback Called after component is updated.\n   * @param {?string} callerName name of the calling function in the public API.\n   * @internal\n   */\n  enqueueForceUpdate: function (publicInstance, callback, callerName) {\n    warnNoop(publicInstance, 'forceUpdate');\n  },\n\n  /**\n   * Replaces all of the state. Always use this or `setState` to mutate state.\n   * You should treat `this.state` as immutable.\n   *\n   * There is no guarantee that `this.state` will be immediately updated, so\n   * accessing `this.state` after calling this method may return the old value.\n   *\n   * @param {ReactClass} publicInstance The instance that should rerender.\n   * @param {object} completeState Next state.\n   * @param {?function} callback Called after component is updated.\n   * @param {?string} callerName name of the calling function in the public API.\n   * @internal\n   */\n  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\n    warnNoop(publicInstance, 'replaceState');\n  },\n\n  /**\n   * Sets a subset of the state. This only exists because _pendingState is\n   * internal. This provides a merging strategy that is not available to deep\n   * properties which is confusing. TODO: Expose pendingState or don't use it\n   * during the merge.\n   *\n   * @param {ReactClass} publicInstance The instance that should rerender.\n   * @param {object} partialState Next partial state to be merged with state.\n   * @param {?function} callback Called after component is updated.\n   * @param {?string} Name of the calling function in the public API.\n   * @internal\n   */\n  enqueueSetState: function (publicInstance, partialState, callback, callerName) {\n    warnNoop(publicInstance, 'setState');\n  }\n};\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction Component(props, context, updater) {\n  this.props = props;\n  this.context = context;\n  this.refs = emptyObject;\n  // We initialize the default updater but the real one gets injected by the\n  // renderer.\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nComponent.prototype.isReactComponent = {};\n\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together.  You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n *        produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\nComponent.prototype.setState = function (partialState, callback) {\n  !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\n  this.updater.enqueueSetState(this, partialState, callback, 'setState');\n};\n\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\nComponent.prototype.forceUpdate = function (callback) {\n  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\n};\n\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\n{\n  var deprecatedAPIs = {\n    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\n    replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\n  };\n  var defineDeprecationWarning = function (methodName, info) {\n    Object.defineProperty(Component.prototype, methodName, {\n      get: function () {\n        lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\n        return undefined;\n      }\n    });\n  };\n  for (var fnName in deprecatedAPIs) {\n    if (deprecatedAPIs.hasOwnProperty(fnName)) {\n      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n    }\n  }\n}\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction PureComponent(props, context, updater) {\n  // Duplicated from Component.\n  this.props = props;\n  this.context = context;\n  this.refs = emptyObject;\n  // We initialize the default updater but the real one gets injected by the\n  // renderer.\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nfunction ComponentDummy() {}\nComponentDummy.prototype = Component.prototype;\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\npureComponentPrototype.constructor = PureComponent;\n// Avoid an extra prototype jump for these methods.\n_assign(pureComponentPrototype, Component.prototype);\npureComponentPrototype.isPureReactComponent = true;\n\nfunction AsyncComponent(props, context, updater) {\n  // Duplicated from Component.\n  this.props = props;\n  this.context = context;\n  this.refs = emptyObject;\n  // We initialize the default updater but the real one gets injected by the\n  // renderer.\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nvar asyncComponentPrototype = AsyncComponent.prototype = new ComponentDummy();\nasyncComponentPrototype.constructor = AsyncComponent;\n// Avoid an extra prototype jump for these methods.\n_assign(asyncComponentPrototype, Component.prototype);\nasyncComponentPrototype.unstable_isAsyncReactComponent = true;\nasyncComponentPrototype.render = function () {\n  return this.props.children;\n};\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n */\nvar ReactCurrentOwner = {\n  /**\n   * @internal\n   * @type {ReactComponent}\n   */\n  current: null\n};\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar RESERVED_PROPS = {\n  key: true,\n  ref: true,\n  __self: true,\n  __source: true\n};\n\nvar specialPropKeyWarningShown;\nvar specialPropRefWarningShown;\n\nfunction hasValidRef(config) {\n  {\n    if (hasOwnProperty.call(config, 'ref')) {\n      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\n      if (getter && getter.isReactWarning) {\n        return false;\n      }\n    }\n  }\n  return config.ref !== undefined;\n}\n\nfunction hasValidKey(config) {\n  {\n    if (hasOwnProperty.call(config, 'key')) {\n      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\n      if (getter && getter.isReactWarning) {\n        return false;\n      }\n    }\n  }\n  return config.key !== undefined;\n}\n\nfunction defineKeyPropWarningGetter(props, displayName) {\n  var warnAboutAccessingKey = function () {\n    if (!specialPropKeyWarningShown) {\n      specialPropKeyWarningShown = true;\n      warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\n    }\n  };\n  warnAboutAccessingKey.isReactWarning = true;\n  Object.defineProperty(props, 'key', {\n    get: warnAboutAccessingKey,\n    configurable: true\n  });\n}\n\nfunction defineRefPropWarningGetter(props, displayName) {\n  var warnAboutAccessingRef = function () {\n    if (!specialPropRefWarningShown) {\n      specialPropRefWarningShown = true;\n      warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\n    }\n  };\n  warnAboutAccessingRef.isReactWarning = true;\n  Object.defineProperty(props, 'ref', {\n    get: warnAboutAccessingRef,\n    configurable: true\n  });\n}\n\n/**\n * Factory method to create a new React element. This no longer adheres to\n * the class pattern, so do not use new to call it. Also, no instanceof check\n * will work. Instead test $$typeof field against Symbol.for('react.element') to check\n * if something is a React Element.\n *\n * @param {*} type\n * @param {*} key\n * @param {string|object} ref\n * @param {*} self A *temporary* helper to detect places where `this` is\n * different from the `owner` when React.createElement is called, so that we\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\n * functions, and as long as `this` and owner are the same, there will be no\n * change in behavior.\n * @param {*} source An annotation object (added by a transpiler or otherwise)\n * indicating filename, line number, and/or other information.\n * @param {*} owner\n * @param {*} props\n * @internal\n */\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\n  var element = {\n    // This tag allow us to uniquely identify this as a React Element\n    $$typeof: REACT_ELEMENT_TYPE,\n\n    // Built-in properties that belong on the element\n    type: type,\n    key: key,\n    ref: ref,\n    props: props,\n\n    // Record the component responsible for creating this element.\n    _owner: owner\n  };\n\n  {\n    // The validation flag is currently mutative. We put it on\n    // an external backing store so that we can freeze the whole object.\n    // This can be replaced with a WeakMap once they are implemented in\n    // commonly used development environments.\n    element._store = {};\n\n    // To make comparing ReactElements easier for testing purposes, we make\n    // the validation flag non-enumerable (where possible, which should\n    // include every environment we run tests in), so the test framework\n    // ignores it.\n    Object.defineProperty(element._store, 'validated', {\n      configurable: false,\n      enumerable: false,\n      writable: true,\n      value: false\n    });\n    // self and source are DEV only properties.\n    Object.defineProperty(element, '_self', {\n      configurable: false,\n      enumerable: false,\n      writable: false,\n      value: self\n    });\n    // Two elements created in two different places should be considered\n    // equal for testing purposes and therefore we hide it from enumeration.\n    Object.defineProperty(element, '_source', {\n      configurable: false,\n      enumerable: false,\n      writable: false,\n      value: source\n    });\n    if (Object.freeze) {\n      Object.freeze(element.props);\n      Object.freeze(element);\n    }\n  }\n\n  return element;\n};\n\n/**\n * Create and return a new ReactElement of the given type.\n * See https://reactjs.org/docs/react-api.html#createelement\n */\nfunction createElement(type, config, children) {\n  var propName;\n\n  // Reserved names are extracted\n  var props = {};\n\n  var key = null;\n  var ref = null;\n  var self = null;\n  var source = null;\n\n  if (config != null) {\n    if (hasValidRef(config)) {\n      ref = config.ref;\n    }\n    if (hasValidKey(config)) {\n      key = '' + config.key;\n    }\n\n    self = config.__self === undefined ? null : config.__self;\n    source = config.__source === undefined ? null : config.__source;\n    // Remaining properties are added to a new props object\n    for (propName in config) {\n      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n        props[propName] = config[propName];\n      }\n    }\n  }\n\n  // Children can be more than one argument, and those are transferred onto\n  // the newly allocated props object.\n  var childrenLength = arguments.length - 2;\n  if (childrenLength === 1) {\n    props.children = children;\n  } else if (childrenLength > 1) {\n    var childArray = Array(childrenLength);\n    for (var i = 0; i < childrenLength; i++) {\n      childArray[i] = arguments[i + 2];\n    }\n    {\n      if (Object.freeze) {\n        Object.freeze(childArray);\n      }\n    }\n    props.children = childArray;\n  }\n\n  // Resolve default props\n  if (type && type.defaultProps) {\n    var defaultProps = type.defaultProps;\n    for (propName in defaultProps) {\n      if (props[propName] === undefined) {\n        props[propName] = defaultProps[propName];\n      }\n    }\n  }\n  {\n    if (key || ref) {\n      if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {\n        var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\n        if (key) {\n          defineKeyPropWarningGetter(props, displayName);\n        }\n        if (ref) {\n          defineRefPropWarningGetter(props, displayName);\n        }\n      }\n    }\n  }\n  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\n}\n\n/**\n * Return a function that produces ReactElements of a given type.\n * See https://reactjs.org/docs/react-api.html#createfactory\n */\n\n\nfunction cloneAndReplaceKey(oldElement, newKey) {\n  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\n\n  return newElement;\n}\n\n/**\n * Clone and return a new ReactElement using element as the starting point.\n * See https://reactjs.org/docs/react-api.html#cloneelement\n */\nfunction cloneElement(element, config, children) {\n  var propName;\n\n  // Original props are copied\n  var props = _assign({}, element.props);\n\n  // Reserved names are extracted\n  var key = element.key;\n  var ref = element.ref;\n  // Self is preserved since the owner is preserved.\n  var self = element._self;\n  // Source is preserved since cloneElement is unlikely to be targeted by a\n  // transpiler, and the original source is probably a better indicator of the\n  // true owner.\n  var source = element._source;\n\n  // Owner will be preserved, unless ref is overridden\n  var owner = element._owner;\n\n  if (config != null) {\n    if (hasValidRef(config)) {\n      // Silently steal the ref from the parent.\n      ref = config.ref;\n      owner = ReactCurrentOwner.current;\n    }\n    if (hasValidKey(config)) {\n      key = '' + config.key;\n    }\n\n    // Remaining properties override existing props\n    var defaultProps;\n    if (element.type && element.type.defaultProps) {\n      defaultProps = element.type.defaultProps;\n    }\n    for (propName in config) {\n      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n        if (config[propName] === undefined && defaultProps !== undefined) {\n          // Resolve default props\n          props[propName] = defaultProps[propName];\n        } else {\n          props[propName] = config[propName];\n        }\n      }\n    }\n  }\n\n  // Children can be more than one argument, and those are transferred onto\n  // the newly allocated props object.\n  var childrenLength = arguments.length - 2;\n  if (childrenLength === 1) {\n    props.children = children;\n  } else if (childrenLength > 1) {\n    var childArray = Array(childrenLength);\n    for (var i = 0; i < childrenLength; i++) {\n      childArray[i] = arguments[i + 2];\n    }\n    props.children = childArray;\n  }\n\n  return ReactElement(element.type, key, ref, self, source, owner, props);\n}\n\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param {?object} object\n * @return {boolean} True if `object` is a valid component.\n * @final\n */\nfunction isValidElement(object) {\n  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\n}\n\nvar ReactDebugCurrentFrame = {};\n\n{\n  // Component that is being worked on\n  ReactDebugCurrentFrame.getCurrentStack = null;\n\n  ReactDebugCurrentFrame.getStackAddendum = function () {\n    var impl = ReactDebugCurrentFrame.getCurrentStack;\n    if (impl) {\n      return impl();\n    }\n    return null;\n  };\n}\n\nvar SEPARATOR = '.';\nvar SUBSEPARATOR = ':';\n\n/**\n * Escape and wrap key so it is safe to use as a reactid\n *\n * @param {string} key to be escaped.\n * @return {string} the escaped key.\n */\nfunction escape(key) {\n  var escapeRegex = /[=:]/g;\n  var escaperLookup = {\n    '=': '=0',\n    ':': '=2'\n  };\n  var escapedString = ('' + key).replace(escapeRegex, function (match) {\n    return escaperLookup[match];\n  });\n\n  return '$' + escapedString;\n}\n\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\nvar didWarnAboutMaps = false;\n\nvar userProvidedKeyEscapeRegex = /\\/+/g;\nfunction escapeUserProvidedKey(text) {\n  return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\n}\n\nvar POOL_SIZE = 10;\nvar traverseContextPool = [];\nfunction getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\n  if (traverseContextPool.length) {\n    var traverseContext = traverseContextPool.pop();\n    traverseContext.result = mapResult;\n    traverseContext.keyPrefix = keyPrefix;\n    traverseContext.func = mapFunction;\n    traverseContext.context = mapContext;\n    traverseContext.count = 0;\n    return traverseContext;\n  } else {\n    return {\n      result: mapResult,\n      keyPrefix: keyPrefix,\n      func: mapFunction,\n      context: mapContext,\n      count: 0\n    };\n  }\n}\n\nfunction releaseTraverseContext(traverseContext) {\n  traverseContext.result = null;\n  traverseContext.keyPrefix = null;\n  traverseContext.func = null;\n  traverseContext.context = null;\n  traverseContext.count = 0;\n  if (traverseContextPool.length < POOL_SIZE) {\n    traverseContextPool.push(traverseContext);\n  }\n}\n\n/**\n * @param {?*} children Children tree container.\n * @param {!string} nameSoFar Name of the key path so far.\n * @param {!function} callback Callback to invoke with each child found.\n * @param {?*} traverseContext Used to pass information throughout the traversal\n * process.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\n  var type = typeof children;\n\n  if (type === 'undefined' || type === 'boolean') {\n    // All of the above are perceived as null.\n    children = null;\n  }\n\n  var invokeCallback = false;\n\n  if (children === null) {\n    invokeCallback = true;\n  } else {\n    switch (type) {\n      case 'string':\n      case 'number':\n        invokeCallback = true;\n        break;\n      case 'object':\n        switch (children.$$typeof) {\n          case REACT_ELEMENT_TYPE:\n          case REACT_CALL_TYPE:\n          case REACT_RETURN_TYPE:\n          case REACT_PORTAL_TYPE:\n            invokeCallback = true;\n        }\n    }\n  }\n\n  if (invokeCallback) {\n    callback(traverseContext, children,\n    // If it's the only child, treat the name as if it was wrapped in an array\n    // so that it's consistent if the number of children grows.\n    nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\n    return 1;\n  }\n\n  var child;\n  var nextName;\n  var subtreeCount = 0; // Count of children found in the current subtree.\n  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\n\n  if (Array.isArray(children)) {\n    for (var i = 0; i < children.length; i++) {\n      child = children[i];\n      nextName = nextNamePrefix + getComponentKey(child, i);\n      subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n    }\n  } else {\n    var iteratorFn = getIteratorFn(children);\n    if (typeof iteratorFn === 'function') {\n      {\n        // Warn about using Maps as children\n        if (iteratorFn === children.entries) {\n          warning(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum());\n          didWarnAboutMaps = true;\n        }\n      }\n\n      var iterator = iteratorFn.call(children);\n      var step;\n      var ii = 0;\n      while (!(step = iterator.next()).done) {\n        child = step.value;\n        nextName = nextNamePrefix + getComponentKey(child, ii++);\n        subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n      }\n    } else if (type === 'object') {\n      var addendum = '';\n      {\n        addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\n      }\n      var childrenString = '' + children;\n      invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\n    }\n  }\n\n  return subtreeCount;\n}\n\n/**\n * Traverses children that are typically specified as `props.children`, but\n * might also be specified through attributes:\n *\n * - `traverseAllChildren(this.props.children, ...)`\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\n *\n * The `traverseContext` is an optional argument that is passed through the\n * entire traversal. It can be used to store accumulations or anything else that\n * the callback might find relevant.\n *\n * @param {?*} children Children tree object.\n * @param {!function} callback To invoke upon traversing each child.\n * @param {?*} traverseContext Context for traversal.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildren(children, callback, traverseContext) {\n  if (children == null) {\n    return 0;\n  }\n\n  return traverseAllChildrenImpl(children, '', callback, traverseContext);\n}\n\n/**\n * Generate a key string that identifies a component within a set.\n *\n * @param {*} component A component that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\nfunction getComponentKey(component, index) {\n  // Do some typechecking here since we call this blindly. We want to ensure\n  // that we don't block potential future ES APIs.\n  if (typeof component === 'object' && component !== null && component.key != null) {\n    // Explicit key\n    return escape(component.key);\n  }\n  // Implicit key determined by the index in the set\n  return index.toString(36);\n}\n\nfunction forEachSingleChild(bookKeeping, child, name) {\n  var func = bookKeeping.func,\n      context = bookKeeping.context;\n\n  func.call(context, child, bookKeeping.count++);\n}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#react.children.foreach\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc\n * @param {*} forEachContext Context for forEachContext.\n */\nfunction forEachChildren(children, forEachFunc, forEachContext) {\n  if (children == null) {\n    return children;\n  }\n  var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\n  traverseAllChildren(children, forEachSingleChild, traverseContext);\n  releaseTraverseContext(traverseContext);\n}\n\nfunction mapSingleChildIntoContext(bookKeeping, child, childKey) {\n  var result = bookKeeping.result,\n      keyPrefix = bookKeeping.keyPrefix,\n      func = bookKeeping.func,\n      context = bookKeeping.context;\n\n\n  var mappedChild = func.call(context, child, bookKeeping.count++);\n  if (Array.isArray(mappedChild)) {\n    mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);\n  } else if (mappedChild != null) {\n    if (isValidElement(mappedChild)) {\n      mappedChild = cloneAndReplaceKey(mappedChild,\n      // Keep both the (mapped) and old keys if they differ, just as\n      // traverseAllChildren used to do for objects as children\n      keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\n    }\n    result.push(mappedChild);\n  }\n}\n\nfunction mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\n  var escapedPrefix = '';\n  if (prefix != null) {\n    escapedPrefix = escapeUserProvidedKey(prefix) + '/';\n  }\n  var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\n  traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\n  releaseTraverseContext(traverseContext);\n}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#react.children.map\n *\n * The provided mapFunction(child, key, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} func The map function.\n * @param {*} context Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */\nfunction mapChildren(children, func, context) {\n  if (children == null) {\n    return children;\n  }\n  var result = [];\n  mapIntoWithKeyPrefixInternal(children, result, null, func, context);\n  return result;\n}\n\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#react.children.count\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\nfunction countChildren(children, context) {\n  return traverseAllChildren(children, emptyFunction.thatReturnsNull, null);\n}\n\n/**\n * Flatten a children object (typically specified as `props.children`) and\n * return an array with appropriately re-keyed children.\n *\n * See https://reactjs.org/docs/react-api.html#react.children.toarray\n */\nfunction toArray(children) {\n  var result = [];\n  mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);\n  return result;\n}\n\n/**\n * Returns the first child in a collection of children and verifies that there\n * is only one child in the collection.\n *\n * See https://reactjs.org/docs/react-api.html#react.children.only\n *\n * The current implementation of this function assumes that a single child gets\n * passed without a wrapper, but the purpose of this helper function is to\n * abstract away the particular structure of children.\n *\n * @param {?object} children Child collection structure.\n * @return {ReactElement} The first and only `ReactElement` contained in the\n * structure.\n */\nfunction onlyChild(children) {\n  !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\n  return children;\n}\n\nvar describeComponentFrame = function (name, source, ownerName) {\n  return '\\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');\n};\n\nfunction getComponentName(fiber) {\n  var type = fiber.type;\n\n  if (typeof type === 'string') {\n    return type;\n  }\n  if (typeof type === 'function') {\n    return type.displayName || type.name;\n  }\n  return null;\n}\n\n/**\n * ReactElementValidator provides a wrapper around a element factory\n * which validates the props passed to the element. This is intended to be\n * used only in DEV and could be replaced by a static type checker for languages\n * that support it.\n */\n\n{\n  var currentlyValidatingElement = null;\n\n  var propTypesMisspellWarningShown = false;\n\n  var getDisplayName = function (element) {\n    if (element == null) {\n      return '#empty';\n    } else if (typeof element === 'string' || typeof element === 'number') {\n      return '#text';\n    } else if (typeof element.type === 'string') {\n      return element.type;\n    } else if (element.type === REACT_FRAGMENT_TYPE) {\n      return 'React.Fragment';\n    } else {\n      return element.type.displayName || element.type.name || 'Unknown';\n    }\n  };\n\n  var getStackAddendum = function () {\n    var stack = '';\n    if (currentlyValidatingElement) {\n      var name = getDisplayName(currentlyValidatingElement);\n      var owner = currentlyValidatingElement._owner;\n      stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner));\n    }\n    stack += ReactDebugCurrentFrame.getStackAddendum() || '';\n    return stack;\n  };\n\n  var VALID_FRAGMENT_PROPS = new Map([['children', true], ['key', true]]);\n}\n\nfunction getDeclarationErrorAddendum() {\n  if (ReactCurrentOwner.current) {\n    var name = getComponentName(ReactCurrentOwner.current);\n    if (name) {\n      return '\\n\\nCheck the render method of `' + name + '`.';\n    }\n  }\n  return '';\n}\n\nfunction getSourceInfoErrorAddendum(elementProps) {\n  if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\n    var source = elementProps.__source;\n    var fileName = source.fileName.replace(/^.*[\\\\\\/]/, '');\n    var lineNumber = source.lineNumber;\n    return '\\n\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\n  }\n  return '';\n}\n\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\nvar ownerHasKeyUseWarning = {};\n\nfunction getCurrentComponentErrorInfo(parentType) {\n  var info = getDeclarationErrorAddendum();\n\n  if (!info) {\n    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\n    if (parentName) {\n      info = '\\n\\nCheck the top-level render call using <' + parentName + '>.';\n    }\n  }\n  return info;\n}\n\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it. Error statuses are cached so a warning\n * will only be shown once.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction validateExplicitKey(element, parentType) {\n  if (!element._store || element._store.validated || element.key != null) {\n    return;\n  }\n  element._store.validated = true;\n\n  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\n  if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\n    return;\n  }\n  ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\n\n  // Usually the current owner is the offender, but if it accepts children as a\n  // property, it may be the creator of the child that's responsible for\n  // assigning it a key.\n  var childOwner = '';\n  if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\n    // Give the component that originally created this child.\n    childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.';\n  }\n\n  currentlyValidatingElement = element;\n  {\n    warning(false, 'Each child in an array or iterator should have a unique \"key\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum());\n  }\n  currentlyValidatingElement = null;\n}\n\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\nfunction validateChildKeys(node, parentType) {\n  if (typeof node !== 'object') {\n    return;\n  }\n  if (Array.isArray(node)) {\n    for (var i = 0; i < node.length; i++) {\n      var child = node[i];\n      if (isValidElement(child)) {\n        validateExplicitKey(child, parentType);\n      }\n    }\n  } else if (isValidElement(node)) {\n    // This element was passed in a valid location.\n    if (node._store) {\n      node._store.validated = true;\n    }\n  } else if (node) {\n    var iteratorFn = getIteratorFn(node);\n    if (typeof iteratorFn === 'function') {\n      // Entry iterators used to provide implicit keys,\n      // but now we print a separate warning for them later.\n      if (iteratorFn !== node.entries) {\n        var iterator = iteratorFn.call(node);\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (isValidElement(step.value)) {\n            validateExplicitKey(step.value, parentType);\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\nfunction validatePropTypes(element) {\n  var componentClass = element.type;\n  if (typeof componentClass !== 'function') {\n    return;\n  }\n  var name = componentClass.displayName || componentClass.name;\n  var propTypes = componentClass.propTypes;\n  if (propTypes) {\n    currentlyValidatingElement = element;\n    checkPropTypes(propTypes, element.props, 'prop', name, getStackAddendum);\n    currentlyValidatingElement = null;\n  } else if (componentClass.PropTypes !== undefined && !propTypesMisspellWarningShown) {\n    propTypesMisspellWarningShown = true;\n    warning(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\n  }\n  if (typeof componentClass.getDefaultProps === 'function') {\n    warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');\n  }\n}\n\n/**\n * Given a fragment, validate that it can only be provided with fragment props\n * @param {ReactElement} fragment\n */\nfunction validateFragmentProps(fragment) {\n  currentlyValidatingElement = fragment;\n\n  var _iteratorNormalCompletion = true;\n  var _didIteratorError = false;\n  var _iteratorError = undefined;\n\n  try {\n    for (var _iterator = Object.keys(fragment.props)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n      var key = _step.value;\n\n      if (!VALID_FRAGMENT_PROPS.has(key)) {\n        warning(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum());\n        break;\n      }\n    }\n  } catch (err) {\n    _didIteratorError = true;\n    _iteratorError = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion && _iterator['return']) {\n        _iterator['return']();\n      }\n    } finally {\n      if (_didIteratorError) {\n        throw _iteratorError;\n      }\n    }\n  }\n\n  if (fragment.ref !== null) {\n    warning(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum());\n  }\n\n  currentlyValidatingElement = null;\n}\n\nfunction createElementWithValidation(type, props, children) {\n  var validType = typeof type === 'string' || typeof type === 'function' || typeof type === 'symbol' || typeof type === 'number';\n  // We warn in this case but don't throw. We expect the element creation to\n  // succeed and there will likely be errors in render.\n  if (!validType) {\n    var info = '';\n    if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\n      info += ' You likely forgot to export your component from the file ' + \"it's defined in, or you might have mixed up default and named imports.\";\n    }\n\n    var sourceInfo = getSourceInfoErrorAddendum(props);\n    if (sourceInfo) {\n      info += sourceInfo;\n    } else {\n      info += getDeclarationErrorAddendum();\n    }\n\n    info += getStackAddendum() || '';\n\n    warning(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', type == null ? type : typeof type, info);\n  }\n\n  var element = createElement.apply(this, arguments);\n\n  // The result can be nullish if a mock or a custom function is used.\n  // TODO: Drop this when these are no longer allowed as the type argument.\n  if (element == null) {\n    return element;\n  }\n\n  // Skip key warning if the type isn't valid since our key validation logic\n  // doesn't expect a non-string/function type and can throw confusing errors.\n  // We don't want exception behavior to differ between dev and prod.\n  // (Rendering will throw with a helpful message and as soon as the type is\n  // fixed, the key warnings will appear.)\n  if (validType) {\n    for (var i = 2; i < arguments.length; i++) {\n      validateChildKeys(arguments[i], type);\n    }\n  }\n\n  if (typeof type === 'symbol' && type === REACT_FRAGMENT_TYPE) {\n    validateFragmentProps(element);\n  } else {\n    validatePropTypes(element);\n  }\n\n  return element;\n}\n\nfunction createFactoryWithValidation(type) {\n  var validatedFactory = createElementWithValidation.bind(null, type);\n  // Legacy hook TODO: Warn if this is accessed\n  validatedFactory.type = type;\n\n  {\n    Object.defineProperty(validatedFactory, 'type', {\n      enumerable: false,\n      get: function () {\n        lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\n        Object.defineProperty(this, 'type', {\n          value: type\n        });\n        return type;\n      }\n    });\n  }\n\n  return validatedFactory;\n}\n\nfunction cloneElementWithValidation(element, props, children) {\n  var newElement = cloneElement.apply(this, arguments);\n  for (var i = 2; i < arguments.length; i++) {\n    validateChildKeys(arguments[i], newElement.type);\n  }\n  validatePropTypes(newElement);\n  return newElement;\n}\n\nvar React = {\n  Children: {\n    map: mapChildren,\n    forEach: forEachChildren,\n    count: countChildren,\n    toArray: toArray,\n    only: onlyChild\n  },\n\n  Component: Component,\n  PureComponent: PureComponent,\n  unstable_AsyncComponent: AsyncComponent,\n\n  Fragment: REACT_FRAGMENT_TYPE,\n\n  createElement: createElementWithValidation,\n  cloneElement: cloneElementWithValidation,\n  createFactory: createFactoryWithValidation,\n  isValidElement: isValidElement,\n\n  version: ReactVersion,\n\n  __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {\n    ReactCurrentOwner: ReactCurrentOwner,\n    // Used by renderers to avoid bundling object-assign twice in UMD bundles:\n    assign: _assign\n  }\n};\n\n{\n  _assign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {\n    // These should not be included in production.\n    ReactDebugCurrentFrame: ReactDebugCurrentFrame,\n    // Shim for React DOM 16.0.0 which still destructured (but not used) this.\n    // TODO: remove in React 17.0.\n    ReactComponentTreeHook: {}\n  });\n}\n\n\n\nvar React$2 = Object.freeze({\n\tdefault: React\n});\n\nvar React$3 = ( React$2 && React ) || React$2;\n\n// TODO: decide on the top-level export form.\n// This is hacky but makes it work with both Rollup and Jest.\nvar react = React$3['default'] ? React$3['default'] : React$3;\n\nmodule.exports = react;\n  })();\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","import React from 'react';\n\nfunction mapToObject(map) {\n  const object = {};\n\n  for (const [key, value] of map.entries()) {\n    if (value instanceof Map) {\n      object[key] = mapToObject(value);\n    } else {\n      object[key] = value;\n    }\n  }\n\n  return object;\n}\n\nfunction createElement(tag, attributes, elements) {\n  const props = mapToObject(attributes);\n  return React.createElement(tag, props, ...elements);\n}\n\nexport default {\n  createElement\n};\n"],"names":["getOwnPropertySymbols","Object","hasOwnProperty","prototype","propIsEnumerable","propertyIsEnumerable","toObject","val","undefined","TypeError","shouldUseNative","assign","test1","String","getOwnPropertyNames","test2","i","fromCharCode","order2","map","n","join","test3","split","forEach","letter","keys","err","target","source","from","to","symbols","s","arguments","length","key","call","emptyObject","process","env","NODE_ENV","freeze","makeEmptyFunction","arg","emptyFunction","thatReturns","thatReturnsFalse","thatReturnsTrue","thatReturnsNull","thatReturnsThis","thatReturnsArgument","q","Symbol","r","t","u","v","w","x","iterator","y","a","b","e","c","encodeURIComponent","Error","name","framesToPop","z","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","A","props","context","refs","updater","isReactComponent","setState","forceUpdate","B","C","D","constructor","m","isPureReactComponent","E","F","unstable_isAsyncReactComponent","render","children","G","current","H","I","ref","__self","__source","J","d","g","k","f","h","Array","l","defaultProps","$$typeof","type","_owner","K","escape","replace","L","M","N","pop","result","keyPrefix","func","count","O","push","P","Q","isArray","next","done","value","toString","R","S","T","p","U","Children","toArray","only","Component","PureComponent","unstable_AsyncComponent","Fragment","createElement","cloneElement","createFactory","bind","version","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","V","default","W","validateFormat","format","invariant","condition","error","args","argIndex","warning","printWarning","_len","_key","message","console","indexOf","_len2","_key2","apply","concat","ReactPropTypesSecret","require$$0","require$$1","require$$2","loggedTypeFailures","checkPropTypes","typeSpecs","values","location","componentName","getStack","typeSpecName","ex","stack","_assign","require$$3","require$$4","require$$5","ReactVersion","hasSymbol","REACT_ELEMENT_TYPE","REACT_CALL_TYPE","REACT_RETURN_TYPE","REACT_PORTAL_TYPE","REACT_FRAGMENT_TYPE","MAYBE_ITERATOR_SYMBOL","FAUX_ITERATOR_SYMBOL","getIteratorFn","maybeIterable","maybeIterator","lowPriorityWarning","warn","lowPriorityWarning$1","didWarnStateUpdateForUnmountedComponent","warnNoop","publicInstance","callerName","displayName","warningKey","ReactNoopUpdateQueue","callback","completeState","partialState","deprecatedAPIs","defineDeprecationWarning","methodName","info","defineProperty","fnName","ComponentDummy","pureComponentPrototype","AsyncComponent","asyncComponentPrototype","RESERVED_PROPS","specialPropKeyWarningShown","specialPropRefWarningShown","hasValidRef","config","getter","getOwnPropertyDescriptor","get","isReactWarning","hasValidKey","defineKeyPropWarningGetter","warnAboutAccessingKey","defineRefPropWarningGetter","warnAboutAccessingRef","ReactElement","self","owner","element","_store","propName","childrenLength","childArray","cloneAndReplaceKey","oldElement","newKey","newElement","_self","_source","isValidElement","object","ReactDebugCurrentFrame","getCurrentStack","getStackAddendum","impl","SEPARATOR","SUBSEPARATOR","escapeRegex","escaperLookup","escapedString","match","didWarnAboutMaps","userProvidedKeyEscapeRegex","escapeUserProvidedKey","text","POOL_SIZE","traverseContextPool","getPooledTraverseContext","mapResult","mapFunction","mapContext","traverseContext","releaseTraverseContext","traverseAllChildrenImpl","nameSoFar","invokeCallback","getComponentKey","child","nextName","subtreeCount","nextNamePrefix","iteratorFn","entries","step","ii","addendum","childrenString","traverseAllChildren","component","index","forEachSingleChild","bookKeeping","forEachChildren","forEachFunc","forEachContext","mapSingleChildIntoContext","childKey","mappedChild","mapIntoWithKeyPrefixInternal","array","prefix","escapedPrefix","mapChildren","countChildren","onlyChild","describeComponentFrame","ownerName","fileName","lineNumber","getComponentName","fiber","currentlyValidatingElement","propTypesMisspellWarningShown","getDisplayName","VALID_FRAGMENT_PROPS","Map","getDeclarationErrorAddendum","getSourceInfoErrorAddendum","elementProps","ownerHasKeyUseWarning","getCurrentComponentErrorInfo","parentType","parentName","validateExplicitKey","validated","currentComponentErrorInfo","childOwner","validateChildKeys","node","validatePropTypes","componentClass","propTypes","PropTypes","getDefaultProps","isReactClassApproved","validateFragmentProps","fragment","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","_step","has","createElementWithValidation","validType","sourceInfo","createFactoryWithValidation","validatedFactory","cloneElementWithValidation","React","React$2","React$3","react","mapToObject","tag","attributes","elements"],"mappings":"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"} 1781 | --------------------------------------------------------------------------------