├── lessons ├── L03_managing-state │ ├── index.js │ ├── index.html │ ├── solution.js │ └── L03_managing-state.md ├── L02_mental-model │ ├── index.html │ ├── homework.js │ ├── index.js │ └── L02_mental-model.md ├── L04_separation │ ├── index.html │ ├── L04_separation.md │ ├── solution.js │ ├── index.js │ └── solution2.js ├── L00_getting-started │ └── L00_getting-started.md └── L01_introduction │ └── L01_introduction.md ├── README.md └── lib ├── normalize.css └── react.development.js /lessons/L03_managing-state/index.js: -------------------------------------------------------------------------------- 1 | function App() { 2 | return "Fix me!"; 3 | } 4 | 5 | ReactDOM.render( 6 | 7 | 8 | , 9 | document.getElementById("root") 10 | ); 11 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # เรียนรู้ React ฉบับ Foundation 2 | 3 | คอร์สสอน React เป็นภาษาไทย เน้นความเข้าใจและการฝึกฝน 4 | 5 | - 📹 [วิดีโออัพลง Youtube](https://www.youtube.com/playlist?list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr) ทั้งหมด 6 | - 📖 เนื้อหาและแบบฝึกหัดอยู่ใน repository นี้ 7 | - [Lesson 0 - Getting Started](/lessons/L00_getting-started/L00_getting-started.md) 8 | - [Lesson 1 - Introduction](/lessons/L01_introduction/L01_introduction.md) 9 | - [Lesson 2 - Mental Model](/lessons/L02_mental-model/L02_mental-model.md) 10 | - [Lesson 3 - Managing State](/lessons/L03_managing-state/L03_managing-state.md) 11 | - [Lesson 4 - Separation](/lessons/L04_separation/L04_separation.md) 12 | 13 | ``` 14 | *** ห้ามนำไปใช้ในเชิงพาณิชย์เด็ดขาด *** 15 | ``` 16 | -------------------------------------------------------------------------------- /lessons/L03_managing-state/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | React in Thai - Learn react foundation 9 | 10 | 11 | 12 |

13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /lessons/L02_mental-model/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | React in Thai - Learn react foundation 9 | 10 | 11 | 12 |

13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /lessons/L04_separation/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | React in Thai - Learn react foundation 9 | 10 | 11 | 12 |

13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /lessons/L02_mental-model/homework.js: -------------------------------------------------------------------------------- 1 | /** 2 | * ใช้ snapshot mental model ทำความเข้าใจโดยไม่เปิด browser 3 | * เมื่อกดปุ่มจะเกิดอะไรขึ้นบ้าง?? 4 | * 5 | * เช็คความเข้าใจใน browser และเพิ่ม console.log ในจุดที่สนใจ 6 | */ 7 | function Homework_1() { 8 | const [loading, setLoading] = React.useState(false); 9 | const [count, setCount] = React.useState(0); 10 | return ( 11 |

12 |

{count}

13 | 24 |

25 | ); 26 | } 27 | 28 | /** 29 | * สร้าง media player แบบง่ายๆ 30 | * มีปุ่มย้อนกลับ (เล่นเพลงก่อนหน้า) 31 | * มีปุ่มเล่น/หยุด (เล่นเพลงก่อนหน้า) 32 | * มีปุ่มไปข้างหน้า (เล่นเพลงถัดไป) 33 | * 34 | * ให้เพิ่ม state และ event handler (onClick) ตามที่สมควร 35 | */ 36 | function Homework_2() { 37 | const SONGS = ["Lavender", "พิง", "เอาปากกามาวง"]; 38 | const pause = true; 39 | const currentSong = SONGS[0]; 40 | return ( 41 |

42 |

{currentSong}

43 |

{pause ? "หยุด" : "กำลังเล่น"}

44 | 45 | 46 | 47 |

48 | ); 49 | } 50 | 51 | function App() { 52 | const sectionLayoutStyle = { 53 | height: "100vh", 54 | display: "flex", 55 | flexDirection: "column", 56 | justifyContent: "center", 57 | alignItems: "center", 58 | }; 59 | return ( 60 |

61 |

62 | 63 |

64 |

65 | 66 |

67 |

68 | ); 69 | } 70 | 71 | ReactDOM.render( 72 | 73 | 74 | , 75 | document.getElementById("root") 76 | ); 77 | -------------------------------------------------------------------------------- /lessons/L02_mental-model/index.js: -------------------------------------------------------------------------------- 1 | /** 2 | * ### ตัวอย่างที่ 1 - counter 3 | */ 4 | function Counter() { 5 | const [count, setCount] = React.useState(0); 6 | return ( 7 | 8 | {count} 9 | 12 | 13 | ); 14 | } 15 | 16 | /** 17 | * ### ตัวอย่างที่ 2 - Search 18 | */ 19 | const MEMBERS = [ 20 | { name: "Tony Stark", level: 20, alive: false }, 21 | { name: "Captain", level: 99, alive: true }, 22 | { name: "Ant man", level: 38, alive: true }, 23 | ]; 24 | 25 | function Search() { 26 | // TODO: ควรจะมี state อะไรเก็บไว้บ้าง หากต้องการให้ค้นหาชื่อได้ 27 | return ( 28 | 29 | 30 | {MEMBERS.map((member) => ( 31 |

32 |

33 | {member.name} 34 |

35 |

36 | {member.level} 37 |

38 |

39 | {member.alive} 40 |

41 |

42 | ))} 43 | 44 | ); 45 | } 46 | 47 | /** 48 | * ### ตัวอย่างที่ 3 - magic counter 49 | */ 50 | function MagicCounter() { 51 | const [count, setCount] = React.useState(0); 52 | return ( 53 | 54 | {count} 55 | 65 | 66 | ); 67 | } 68 | 69 | function App() { 70 | const sectionLayoutStyle = { 71 | height: "100vh", 72 | display: "flex", 73 | flexDirection: "column", 74 | justifyContent: "center", 75 | alignItems: "center", 76 | }; 77 | return ( 78 |

79 |

80 | 81 |

82 |

83 | 84 |

85 |

86 | 87 |

88 |

89 | ); 90 | } 91 | 92 | ReactDOM.render( 93 | 94 | 95 | , 96 | document.getElementById("root") 97 | ); 98 | -------------------------------------------------------------------------------- /lessons/L04_separation/L04_separation.md: -------------------------------------------------------------------------------- 1 |

2 | 3 | ◀ Previous Lesson 4 | 5 | | 6 | 7 | Next Lesson ▶ (coming soon) 8 | 9 |

10 |

11 | 12 | >>> ไปหน้าสารบัญ <<< 13 | 14 |

15 | 16 | # บทที่ 4 - Separation 17 | 18 | > Video ประกอบการสอน: [https://www.youtube.com/watch?v=8qZvs8T59XQ](https://www.youtube.com/watch?v=8qZvs8T59XQ&list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr) 19 | 20 | จากบทที่แล้วเราได้สร้าง note application ที่มีฟีเจอร์พอสมควรแล้ว แต่ก่อนที่เราจะเพิ่มฟีเจอร์เข้าไปอีก เรามาลอง refactor แอพของเราให้แบ่งการทำงานออกเป็นส่วนย่อยๆก่อนดีกว่า 21 | 22 | การแบ่งแต่ละส่วนในแอพให้แยกจากกัน จะทำให้เราสามารถเทสง่ายขึ้น(คอร์สนี้ผมไม่ได้สอนการเขียนเทส) และเมื่อเราเพิ่มฟีเจอร์อื่นๆเข้าไปจะช่วยให้เราไม่สร้างผลกระทบต่อส่วนอื่นๆ แต่แน่นอนว่าในหลายๆครั้งการทำแบบนี้ก็ไม่ใช้เรื่องที่ดีเสมอไป ขึ้นอยู่กับความเหมาะสมในแต่ละสถานการณ์ 23 | 24 | ## แบ่งการทำงาน 25 | 26 | วิธีที่ง่ายที่สุดคือการแยกการแสดงผลกับ logic ออกจากกัน ในเคสของ note application นี้ผมจะแบ่งออกเป็น 2 components ย่อย โดยที่มี state ของ `notes` และ `selectedNote` อยู่ที่ App 27 | 28 | ![image](https://user-images.githubusercontent.com/18292247/147404904-67d2b151-ed23-4cff-ba0a-51e56bee04ee.png) 29 | 30 | - `NoteList`: แสดงผลโน้ตที่เรามี และมี interface ในการเลือกและลบโน้ต 31 | - `NoteEditor`: แสดงผลฟอร์ม 32 | 33 | ### NoteList 34 | 35 | Component นี้ควรทำหน้าที่ในการแสดงผลอยากเดียว ไม่ควรมี logic อยู่ภายในตัวเอง. ผลลัพธ์จะออกมาหน้าตาเป็นแบบนี้ 36 | 37 | ```js 38 | {}} 41 | onDeleteNote={(note) => {}} 42 | /> 43 | ``` 44 | 45 | ### NoteEditor 46 | 47 | สามารถรับ note เพื่อนำค่าต่างๆมาแสดงผลลงในฟอร์มได้ และ users สามารถแก้ไข บันทึก รวมถึงมีฟีเจอร์ undo, redo ภายในตัวเอง 48 | 49 | ```js 50 | {}} 53 | /> 54 | ``` 55 | 56 | 📹 สำหรับการ refactor ดูใน[วิดีโอ](https://www.youtube.com/watch?v=8qZvs8T59XQ&list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr)จะได้อรรถรสมากกว่า 😂 57 | 58 | --- 59 | 60 |

61 | 62 | ◀ Previous Lesson 63 | 64 | | 65 | 66 | Next Lesson ▶ (coming soon) 67 | 68 |

69 |

70 | 71 | >>> ไปหน้าสารบัญ <<< 72 | 73 |

74 | -------------------------------------------------------------------------------- /lessons/L00_getting-started/L00_getting-started.md: -------------------------------------------------------------------------------- 1 |

2 | 3 | ◀ Previous Lesson 4 | 5 | | 6 | 7 | Next Lesson ▶ 8 | 9 |

10 |

11 | 12 | >>> ไปหน้าสารบัญ <<< 13 | 14 |

15 | 16 | # บทที่ 0 - เตรียมความพร้อม 17 | 18 | > Video ประกอบการสอน: [https://www.youtube.com/watch?v=fI06CT84FRQ](https://www.youtube.com/watch?v=fI06CT84FRQ&list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr) 19 | 20 | ## เนื้อหาในคอร์ส 21 | 22 | เนื้อหาในคอร์สนี้จะเน้นไปที่การสร้างรากฐานและความเข้าใจเกี่ยวกับ React เพื่อให้สามารถนำไปต่อยอด, ประยุกต์, และสร้างเว็บแอพลิเคชั่นที่มีความหลากหลายและซับซ้อนได้ 23 | 24 | สื่งที่ไม่ได้เน้นคือ 25 | - HTML, CSS 26 | - performance optimization 27 | - testing 28 | 29 | ## ระดับและความรู้พื้นฐาน 30 | 31 | จริงๆไม่จำเป็นมาก แต่ถ้ามีก็ดี ในวิดีโอจะพยายามแปะลิ้งค์ไว้ให้อ่านเพิ่มเติม 32 | 33 | - [basic HTML](https://developer.mozilla.org/en-US/docs/Learn/HTML) 34 | - [basic CSS](https://developer.mozilla.org/en-US/docs/Learn/CSS) 35 | - [basic JS](https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/JavaScript_basics) 36 | - [basic React](https://reactjs.org/docs/getting-started.html) (optional) 37 | 38 | > ในคอร์สจะไม่อธิบายรายละเอียดการใช้ HTML และ CSS (อาจมีพูดถึงบ้างเล็กน้อย) 39 | 40 | ## วิธีการเรียนการสอน 41 | 42 | - 📹 วิดีโอทั้งหมดจะอัดลงใน Youtube 43 | - 📚 บทเรียนและ code อยู่ใน repository นี้ 44 | - แนะนำว่าให้เริ่มตั้งแต่บทที่ 0 (พยายามอย่าข้าม) เนื้อหาตัดมาให้แล้วแต่เนื้อๆ คลิปละ 10-15 นาที ถ้าอยากได้น้ำด้วยไปติดตามในเพจ [React ไปวันๆ](https://www.facebook.com/devMasterSomeday/) นะคับ 45 | - แนะนำให้ทำแบบฝึกหัดในตอนท้ายของวิดีโอ (ถ้ามี) เพราะถ้าอยากเข้าใจด้วยตัวเองจริงๆต้องลงมือทำ ผมช่วยได้แค่แนะนำและเล่าประสบการณ์ให้ฟังเท่านั้น 46 | - เนื่องจากวิธีการสอนเน้นความเข้าใจ ในวิดีโอจะพูดถึงจากปัญหาหรือสิ่งที่ต้องการก่อน จากนั้นค่อยนำเครื่องมือ(react API) ที่เหมาะสมเข้ามาใช้ 47 | - syntax ทั้งหมด จะเขียนด้วย ES6 ขึ้นไป 48 | - ส่วนใหญ่ผมจะพูดไทยบ้างอังกฤษบ้างเพราะศัพท์บางคำใช้ภาษาอังกฤษจะดีกว่า (ถ้ามีคำหยาบ ต้องขออภัย 🙏) 49 | - ภาษาที่ใช้ในการพูดหรือพิม อาจมีความผิดพลาดได้ (ส่วนใหญ่จะไม่ได้เป็นทางการ) หากในส่วนไหนมีความผิดพลาดสามารถเปิด PR เข้ามาได้เลยครับ 50 | - โปรดอย่าคาดหวังเรื่อง production ในการตัดต่อวิดีโอนะครับ 🤣 เป้าหมายคือให้พอดูได้ 51 | 52 | ## ค่าใช้จ่าย 53 | 54 | คอร์สนี้ **Free** ทั้งหมด 55 | 56 | ### !!!ห้ามนําไปใช้เชิงพาณิชย์ เด็ดขาด!!! 57 | 58 | ## เครื่องมือและการติดตั้ง 59 | 60 | - [clone โปรเจคลงในเครื่อง](https://github.com/React-in-Thai/learn-react-foundation.git) 61 | - เปิดด้วย [VSCode](https://code.visualstudio.com/download) (IDE อื่นสามารถใช้ได้เช่นกัน) 62 | - ติดตั้ง `serve` ด้วย yarn หรือ npm 63 | ```bash 64 | yarn global add serve 65 | ``` 66 | or 67 | ```bash 68 | npm install -g serve 69 | ``` 70 | - เปิดโปรเจคขึ้นมาแล้วรัน `serve` ได้เลย 71 | 72 | > คิดว่ารองรับทั้ง mac และ window นะครับ ถ้าติดปัญหาอะไรลองหาวิธีแก้ด้วยตัวเองก่อน(เพราะคุณจะต้องเจออีกเยอะ) แต่ถ้าไม่ได้จริงๆให้เปิด [issue](https://github.com/React-in-Thai/learn-react-foundation/issues) ไว้ 73 | 74 | ## โครงสร้าง repo 75 | 76 | - สคริปตอนพูดในวิดีโอจะอยู่ในโฟลเดอร์ `/lessons/$lesson_number/$lesson_number.md` (สคริปจะไม่ตรงกับในวิดีโอเป๊ะๆ) 77 | 78 | --- 79 | 80 |

81 | 82 | ◀ Previous Lesson 83 | 84 | | 85 | 86 | Next Lesson ▶ 87 | 88 |

89 |

90 | 91 | >>> ไปหน้าสารบัญ <<< 92 | 93 |

94 | -------------------------------------------------------------------------------- /lessons/L03_managing-state/solution.js: -------------------------------------------------------------------------------- 1 | function App() { 2 | const [title, setTitle] = React.useState(""); 3 | const [content, setContent] = React.useState(""); 4 | const [history, setHistory] = React.useState([]); 5 | const [future, setFuture] = React.useState([]); 6 | const [notes, setNotes] = React.useState([]); 7 | const [selectedNote, setSelectedNote] = React.useState(null); 8 | return ( 9 |

12 |

19 | {notes.map((note, index) => ( 20 |

21 |

22 | {note.title} 23 |

24 |

25 | {(note.content || "").slice(0, 40)} 26 |

27 |

28 | 37 | 47 |

48 |

49 | ))} 50 |

51 |

52 |

Note Editor

53 | 54 | Title 55 |

56 | { 60 | setTitle(event.target.value); 61 | setHistory((latestHistory) => [ 62 | { title, content }, 63 | ...latestHistory, 64 | ]); 65 | }} 66 | /> 67 |

68 |
69 | 70 | content 71 |

72 |

{
 76 |               setContent(event.target.value);
 77 |               setHistory((latestHistory) => [
 78 |                 { title, content },
 79 |                 ...latestHistory,
 80 |               ]);
 81 |             }}
 82 |           />
 83 |         </div>
 84 | 
 85 |         <br />
 86 |         <div style={{ display: "flex", gap: "0.5rem" }}>
 87 |           <button
 88 |             disabled={!history.length}
 89 |             onClick={() => {
 90 |               const previousNote = history[0];
 91 |               if (previousNote) {
 92 |                 setTitle(previousNote.title);
 93 |                 setContent(previousNote.content);
 94 |                 setHistory((latestHistory) => latestHistory.slice(1));
 95 |                 setFuture((latestFuture) => [
 96 |                   { title, content },
 97 |                   ...latestFuture,
 98 |                 ]);
 99 |               }
100 |             }}
101 |           >
102 |             Undo
103 |           </button>
104 |           <button
105 |             disabled={!future.length}
106 |             onClick={() => {
107 |               const lastNote = future[0];
108 |               if (lastNote) {
109 |                 setTitle(lastNote.title);
110 |                 setContent(lastNote.content);
111 |                 setHistory((latestHistory) => [
112 |                   { title, content },
113 |                   ...latestHistory,
114 |                 ]);
115 |                 setFuture((latestFuture) => latestFuture.slice(1));
116 |               }
117 |             }}
118 |           >
119 |             Redo
120 |           </button>
121 |           <button
122 |             disabled={!title}
123 |             style={{ width: 80 }}
124 |             onClick={() => {
125 |               setTitle("");
126 |               setContent("");
127 |               setFuture([]);
128 |               setHistory([]);
129 |               if (selectedNote) {
130 |                 setNotes((latestNotes) =>
131 |                   latestNotes.map((item) => {
132 |                     if (item.id === selectedNote.id) {
133 |                       return { ...item, title, content };
134 |                     }
135 |                     return item;
136 |                   })
137 |                 );
138 |                 setSelectedNote(null);
139 |               } else {
140 |                 setNotes((latestNotes) => [
141 |                   { id: Date.now(), title, content },
142 |                   ...latestNotes,
143 |                 ]);
144 |               }
145 |             }}
146 |           >
147 |             Save
148 |           </button>
149 |         </div>
150 |       </div>
151 |     </div>
152 |   );
153 | }
154 | 
155 | ReactDOM.render(
156 |   <React.StrictMode>
157 |     <App />
158 |   </React.StrictMode>,
159 |   document.getElementById("root")
160 | );
161 |

--------------------------------------------------------------------------------
/lessons/L04_separation/solution.js:
--------------------------------------------------------------------------------
  1 | const NoteList = ({ notes, onPickNote, onDeleteNote }) => {
  2 |   return notes.map((note, index) => (
  3 |     <div key={index} style={{ borderBottom: "1px solid #e5e5e5" }}>
  4 |       <p style={{ fontWeight: "bold", fontSize: "0.875rem" }}>{note.title}</p>
  5 |       <p style={{ fontSize: "0.75rem" }}>{(note.content || "").slice(0, 40)}</p>
  6 |       <div style={{ display: "flex", gap: "0.25rem" }}>
  7 |         <button onClick={() => onPickNote(note)}>Edit</button>
  8 |         <button onClick={() => onDeleteNote(note)}>Delete</button>
  9 |       </div>
 10 |     </div>
 11 |   ));
 12 | };
 13 | 
 14 | const NoteEditor = ({ note, onSave }) => {
 15 |   const [title, setTitle] = React.useState("");
 16 |   const [content, setContent] = React.useState("");
 17 |   const [history, setHistory] = React.useState([]);
 18 |   const [future, setFuture] = React.useState([]);
 19 |   React.useEffect(() => {
 20 |     if (note) {
 21 |       setTitle(note.title);
 22 |       setContent(note.content);
 23 |     }
 24 |   }, [note]);
 25 |   return (
 26 |     <React.Fragment>
 27 |       <label htmlFor="title">Title</label>
 28 |       <div>
 29 |         <input
 30 |           id="title"
 31 |           value={title}
 32 |           onChange={(event) => {
 33 |             setTitle(event.target.value);
 34 |             setHistory((latestHistory) => [
 35 |               { title, content },
 36 |               ...latestHistory,
 37 |             ]);
 38 |           }}
 39 |         />
 40 |       </div>
 41 |       <br />
 42 | 
 43 |       <label htmlFor="content">content</label>
 44 |       <div>
 45 |         <textarea
 46 |           id="content"
 47 |           value={content}
 48 |           onChange={(event) => {
 49 |             setContent(event.target.value);
 50 |             setHistory((latestHistory) => [
 51 |               { title, content },
 52 |               ...latestHistory,
 53 |             ]);
 54 |           }}
 55 |         />
 56 |       </div>
 57 | 
 58 |       <br />
 59 |       <div style={{ display: "flex", gap: "0.5rem" }}>
 60 |         <button
 61 |           disabled={!history.length}
 62 |           onClick={() => {
 63 |             const previousNote = history[0];
 64 |             if (previousNote) {
 65 |               setTitle(previousNote.title);
 66 |               setContent(previousNote.content);
 67 |               setHistory((latestHistory) => latestHistory.slice(1));
 68 |               setFuture((latestFuture) => [
 69 |                 { title, content },
 70 |                 ...latestFuture,
 71 |               ]);
 72 |             }
 73 |           }}
 74 |         >
 75 |           Undo
 76 |         </button>
 77 |         <button
 78 |           disabled={!future.length}
 79 |           onClick={() => {
 80 |             const lastNote = future[0];
 81 |             if (lastNote) {
 82 |               setTitle(lastNote.title);
 83 |               setContent(lastNote.content);
 84 |               setHistory((latestHistory) => [
 85 |                 { title, content },
 86 |                 ...latestHistory,
 87 |               ]);
 88 |               setFuture((latestFuture) => latestFuture.slice(1));
 89 |             }
 90 |           }}
 91 |         >
 92 |           Redo
 93 |         </button>
 94 |         <button
 95 |           disabled={!title}
 96 |           style={{ width: 80 }}
 97 |           onClick={() => {
 98 |             setTitle("");
 99 |             setContent("");
100 |             setFuture([]);
101 |             setHistory([]);
102 |             onSave({ title, content });
103 |           }}
104 |         >
105 |           Save
106 |         </button>
107 |       </div>
108 |     </React.Fragment>
109 |   );
110 | };
111 | 
112 | function App() {
113 |   const [notes, setNotes] = React.useState([]);
114 |   const [selectedNote, setSelectedNote] = React.useState(null);
115 |   return (
116 |     <div
117 |       style={{ maxWidth: 400, margin: "auto", display: "flex", gap: "1rem" }}
118 |     >
119 |       <div
120 |         style={{
121 |           flexBasis: 120,
122 |           borderRight: "1px solid #e5e5e5",
123 |           padding: "1rem",
124 |         }}
125 |       >
126 |         <NoteList
127 |           notes={notes}
128 |           onPickNote={(note) => {
129 |             setSelectedNote(note);
130 |           }}
131 |           onDeleteNote={(note) => {
132 |             setSelectedNote(null);
133 |             setNotes((latestNotes) =>
134 |               latestNotes.filter((item) => item.id !== note.id)
135 |             );
136 |           }}
137 |         />
138 |       </div>
139 |       <div>
140 |         <h1 style={{ fontSize: "1.25rem" }}>Note Editor</h1>
141 | 
142 |         <NoteEditor
143 |           note={selectedNote}
144 |           onSave={(note) => {
145 |             if (selectedNote) {
146 |               setNotes((latestNotes) =>
147 |                 latestNotes.map((item) => {
148 |                   if (item.id === selectedNote.id) {
149 |                     return { ...item, ...note };
150 |                   }
151 |                   return item;
152 |                 })
153 |               );
154 |               setSelectedNote(null);
155 |             } else {
156 |               setNotes((latestNotes) => [
157 |                 { ...note, id: Date.now() },
158 |                 ...latestNotes,
159 |               ]);
160 |             }
161 |           }}
162 |         />
163 |       </div>
164 |     </div>
165 |   );
166 | }
167 | 
168 | ReactDOM.render(
169 |   <React.StrictMode>
170 |     <App />
171 |   </React.StrictMode>,
172 |   document.getElementById("root")
173 | );
174 |

--------------------------------------------------------------------------------
/lessons/L04_separation/index.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Homework:
  3 |  * - refactor component to NoteList & NoteEditor
  4 |  * - refactor NoteEditor state to useTimeTravel
  5 |  */
  6 | function NoteApp() {
  7 |   const [title, setTitle] = React.useState("");
  8 |   const [content, setContent] = React.useState("");
  9 |   const [history, setHistory] = React.useState([]);
 10 |   const [future, setFuture] = React.useState([]);
 11 |   const [notes, setNotes] = React.useState([]);
 12 |   const [selectedNote, setSelectedNote] = React.useState(null);
 13 |   return (
 14 |     <div
 15 |       style={{ maxWidth: 400, margin: "auto", display: "flex", gap: "1rem" }}
 16 |     >
 17 |       <div
 18 |         style={{
 19 |           flexBasis: 120,
 20 |           borderRight: "1px solid #e5e5e5",
 21 |           padding: "1rem",
 22 |         }}
 23 |       >
 24 |         {notes.map((note, index) => (
 25 |           <div key={index} style={{ borderBottom: "1px solid #e5e5e5" }}>
 26 |             <p style={{ fontWeight: "bold", fontSize: "0.875rem" }}>
 27 |               {note.title}
 28 |             </p>
 29 |             <p style={{ fontSize: "0.75rem" }}>
 30 |               {(note.content || "").slice(0, 40)}
 31 |             </p>
 32 |             <div style={{ display: "flex", gap: "0.25rem" }}>
 33 |               <button
 34 |                 onClick={() => {
 35 |                   setSelectedNote(note);
 36 |                   setTitle(note.title);
 37 |                   setContent(note.content);
 38 |                 }}
 39 |               >
 40 |                 Edit
 41 |               </button>
 42 |               <button
 43 |                 onClick={() => {
 44 |                   setSelectedNote(null);
 45 |                   return setNotes((latestNotes) =>
 46 |                     latestNotes.filter((item) => item.id !== note.id)
 47 |                   );
 48 |                 }}
 49 |               >
 50 |                 Delete
 51 |               </button>
 52 |             </div>
 53 |           </div>
 54 |         ))}
 55 |       </div>
 56 |       <div>
 57 |         <h1 style={{ fontSize: "1.25rem" }}>Note Editor</h1>
 58 | 
 59 |         <label htmlFor="title">Title</label>
 60 |         <div>
 61 |           <input
 62 |             id="title"
 63 |             value={title}
 64 |             onChange={(event) => {
 65 |               setTitle(event.target.value);
 66 |               setHistory((latestHistory) => [
 67 |                 { title, content },
 68 |                 ...latestHistory,
 69 |               ]);
 70 |             }}
 71 |           />
 72 |         </div>
 73 |         <br />
 74 | 
 75 |         <label htmlFor="content">content</label>
 76 |         <div>
 77 |           <textarea
 78 |             id="content"
 79 |             value={content}
 80 |             onChange={(event) => {
 81 |               setContent(event.target.value);
 82 |               setHistory((latestHistory) => [
 83 |                 { title, content },
 84 |                 ...latestHistory,
 85 |               ]);
 86 |             }}
 87 |           />
 88 |         </div>
 89 | 
 90 |         <br />
 91 |         <div style={{ display: "flex", gap: "0.5rem" }}>
 92 |           <button
 93 |             disabled={!history.length}
 94 |             onClick={() => {
 95 |               const previousNote = history[0];
 96 |               if (previousNote) {
 97 |                 setTitle(previousNote.title);
 98 |                 setContent(previousNote.content);
 99 |                 setHistory((latestHistory) => latestHistory.slice(1));
100 |                 setFuture((latestFuture) => [
101 |                   { title, content },
102 |                   ...latestFuture,
103 |                 ]);
104 |               }
105 |             }}
106 |           >
107 |             Undo
108 |           </button>
109 |           <button
110 |             disabled={!future.length}
111 |             onClick={() => {
112 |               const lastNote = future[0];
113 |               if (lastNote) {
114 |                 setTitle(lastNote.title);
115 |                 setContent(lastNote.content);
116 |                 setHistory((latestHistory) => [
117 |                   { title, content },
118 |                   ...latestHistory,
119 |                 ]);
120 |                 setFuture((latestFuture) => latestFuture.slice(1));
121 |               }
122 |             }}
123 |           >
124 |             Redo
125 |           </button>
126 |           <button
127 |             disabled={!title}
128 |             style={{ width: 80 }}
129 |             onClick={() => {
130 |               setTitle("");
131 |               setContent("");
132 |               setFuture([]);
133 |               setHistory([]);
134 |               if (selectedNote) {
135 |                 setNotes((latestNotes) =>
136 |                   latestNotes.map((item) => {
137 |                     if (item.id === selectedNote.id) {
138 |                       return { ...item, title, content };
139 |                     }
140 |                     return item;
141 |                   })
142 |                 );
143 |                 setSelectedNote(null);
144 |               } else {
145 |                 setNotes((latestNotes) => [
146 |                   { id: Date.now(), title, content },
147 |                   ...latestNotes,
148 |                 ]);
149 |               }
150 |             }}
151 |           >
152 |             Save
153 |           </button>
154 |         </div>
155 |       </div>
156 |     </div>
157 |   );
158 | }
159 | 
160 | ReactDOM.render(
161 |   <React.StrictMode>
162 |     <App />
163 |   </React.StrictMode>,
164 |   document.getElementById("root")
165 | );
166 |

--------------------------------------------------------------------------------
/lessons/L04_separation/solution2.js:
--------------------------------------------------------------------------------
  1 | const NoteList = ({ notes, onPickNote, onDeleteNote }) => {
  2 |   return notes.map((note, index) => (
  3 |     <div key={index} style={{ borderBottom: "1px solid #e5e5e5" }}>
  4 |       <p style={{ fontWeight: "bold", fontSize: "0.875rem" }}>{note.title}</p>
  5 |       <p style={{ fontSize: "0.75rem" }}>{(note.content || "").slice(0, 40)}</p>
  6 |       <div style={{ display: "flex", gap: "0.25rem" }}>
  7 |         <button onClick={() => onPickNote(note)}>Edit</button>
  8 |         <button onClick={() => onDeleteNote(note)}>Delete</button>
  9 |       </div>
 10 |     </div>
 11 |   ));
 12 | };
 13 | 
 14 | const useTimeTravel = (data) => {
 15 |   const [present, setPresent] = React.useState(data);
 16 |   const [history, setHistory] = React.useState([]);
 17 |   const [future, setFuture] = React.useState([]);
 18 | 
 19 |   React.useEffect(() => {
 20 |     if (data) {
 21 |       setPresent(data);
 22 |     }
 23 |   }, [data]);
 24 | 
 25 |   return {
 26 |     present,
 27 |     history,
 28 |     future,
 29 |     update: (partialData) => {
 30 |       setPresent((latestPresent) => ({ ...latestPresent, ...partialData }));
 31 |       setHistory((latestHistory) => [present, ...latestHistory]);
 32 |     },
 33 |     undo: () => {
 34 |       const previousNote = history[0];
 35 |       if (previousNote) {
 36 |         setPresent(previousNote);
 37 |         setHistory((latestHistory) => latestHistory.slice(1));
 38 |         setFuture((latestFuture) => [present, ...latestFuture]);
 39 |       }
 40 |     },
 41 |     redo: () => {
 42 |       const lastNote = future[0];
 43 |       if (lastNote) {
 44 |         setPresent(lastNote);
 45 |         setHistory((latestHistory) => [present, ...latestHistory]);
 46 |         setFuture((latestFuture) => latestFuture.slice(1));
 47 |       }
 48 |     },
 49 |     reset: (initialData) => {
 50 |       setPresent(initialData);
 51 |       setFuture([]);
 52 |       setHistory([]);
 53 |     },
 54 |   };
 55 | };
 56 | 
 57 | const NoteEditor = ({ note, onSave }) => {
 58 |   const defaultNote = React.useMemo(() => ({ title: "", content: "" }), []);
 59 |   const {
 60 |     history,
 61 |     present: { title, content },
 62 |     future,
 63 |     update,
 64 |     undo,
 65 |     redo,
 66 |     reset,
 67 |   } = useTimeTravel(note || defaultNote);
 68 |   return (
 69 |     <React.Fragment>
 70 |       <label htmlFor="title">Title</label>
 71 |       <div>
 72 |         <input
 73 |           id="title"
 74 |           value={title}
 75 |           onChange={(event) => {
 76 |             update({ title: event.target.value });
 77 |           }}
 78 |         />
 79 |       </div>
 80 |       <br />
 81 | 
 82 |       <label htmlFor="content">content</label>
 83 |       <div>
 84 |         <textarea
 85 |           id="content"
 86 |           value={content}
 87 |           onChange={(event) => {
 88 |             update({ content: event.target.value });
 89 |           }}
 90 |         />
 91 |       </div>
 92 | 
 93 |       <br />
 94 |       <div style={{ display: "flex", gap: "0.5rem" }}>
 95 |         <button
 96 |           disabled={!history.length}
 97 |           onClick={() => {
 98 |             undo();
 99 |           }}
100 |         >
101 |           Undo
102 |         </button>
103 |         <button
104 |           disabled={!future.length}
105 |           onClick={() => {
106 |             redo();
107 |           }}
108 |         >
109 |           Redo
110 |         </button>
111 |         <button
112 |           disabled={!title}
113 |           style={{ width: 80 }}
114 |           onClick={() => {
115 |             reset({ title: "", content: "" });
116 |             onSave({ title, content });
117 |           }}
118 |         >
119 |           Save
120 |         </button>
121 |       </div>
122 |     </React.Fragment>
123 |   );
124 | };
125 | 
126 | function App() {
127 |   const [notes, setNotes] = React.useState([]);
128 |   const [selectedNote, setSelectedNote] = React.useState(null);
129 |   return (
130 |     <div
131 |       style={{ maxWidth: 400, margin: "auto", display: "flex", gap: "1rem" }}
132 |     >
133 |       <div
134 |         style={{
135 |           flexBasis: 120,
136 |           borderRight: "1px solid #e5e5e5",
137 |           padding: "1rem",
138 |         }}
139 |       >
140 |         <NoteList
141 |           notes={notes}
142 |           onPickNote={(note) => {
143 |             setSelectedNote(note);
144 |           }}
145 |           onDeleteNote={(note) => {
146 |             setSelectedNote(null);
147 |             setNotes((latestNotes) =>
148 |               latestNotes.filter((item) => item.id !== note.id)
149 |             );
150 |           }}
151 |         />
152 |       </div>
153 |       <div>
154 |         <h1 style={{ fontSize: "1.25rem" }}>Note Editor</h1>
155 | 
156 |         <NoteEditor
157 |           note={selectedNote}
158 |           onSave={(note) => {
159 |             if (selectedNote) {
160 |               setNotes((latestNotes) =>
161 |                 latestNotes.map((item) => {
162 |                   if (item.id === selectedNote.id) {
163 |                     return { ...item, ...note };
164 |                   }
165 |                   return item;
166 |                 })
167 |               );
168 |               setSelectedNote(null);
169 |             } else {
170 |               setNotes((latestNotes) => [
171 |                 { ...note, id: Date.now() },
172 |                 ...latestNotes,
173 |               ]);
174 |             }
175 |           }}
176 |         />
177 |       </div>
178 |     </div>
179 |   );
180 | }
181 | 
182 | ReactDOM.render(
183 |   <React.StrictMode>
184 |     <App />
185 |   </React.StrictMode>,
186 |   document.getElementById("root")
187 | );
188 |

--------------------------------------------------------------------------------
/lessons/L03_managing-state/L03_managing-state.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 |   <a href="../L02_mental-model/L02_mental-model.md">
  3 |     ◀ Previous Lesson
  4 |   </a>
  5 |    | 
  6 |   <a href="../L04_separation/L04_separation.md">
  7 |     Next Lesson ▶
  8 |   </a>
  9 | </div>
 10 | <div align="center">
 11 |   <a href="../../README.md" style="font-size: 24px;">
 12 |     >>> ไปหน้าสารบัญ <<<
 13 |   </a>
 14 | </div>
 15 | 
 16 | # บทเรียน 3 - จัดการ state
 17 | 
 18 | > Video ประกอบการสอน: [https://www.youtube.com/watch?v=fbhoZlCwM4U](https://www.youtube.com/watch?v=fbhoZlCwM4U&list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr)
 19 | 
 20 | การเขียนหน้าบ้านจะต้องจัดการกับ state เป็นหลัก สำหรับในคอร์สนี้เราจะแบ่ง state ออกเป็น 2 กลุ่ม
 21 | - UI state: ข้อมูลที่ users นั้น interact ด้วย เช่น ข้อความที่พิม ตัวเลือกต่างๆที่สามารถเปลี่ยนได้
 22 | - Server state: ข้อมูลที่มาจากหลังบ้านหรือ 3rd party service อื่นๆ
 23 | 
 24 | เรามาเริ่มจาก UI state กันก่อนเลย ด้วยการสร้างแอพโน้ตบุ๊คแบบง่ายๆ แล้วเราจะค่อยๆเพิ่มฟีเจอร์เข้าไป
 25 | 
 26 | ## 1st requirement - Editor
 27 | 
 28 | โจทย์แรกคือให้สร้าง notebook editor ขึ้นมา โดยสามารถพิมพ์ชื่อและเนื้อหาของโน้ตได้
 29 | 
 30 | เปิดโฟลเดอร์ `/lessons/L04_managing-state/` ขึ้นมา จะเห็นว่ามีไฟล์ `index.js` และ `index.html` อยู่
 31 | - ใช้ vscode เปิด `index.js`
 32 | - ใช้ chrome เปิด `index.html`
 33 | 
 34 | เมื่อเราแก้โค้ดใน `index.js` ให้กดบันทึก แล้ว refresh ที่หน้า chrome เพื่อเห็นการเปลี่ยนแปลง
 35 | 
 36 | ทริกในการสร้าง state
 37 | - ส่วนใหญ่จะเป็นสิ่งที่ users สามารถแก้ไขได้
 38 | - ควรจะเป็นส่วนที่เล็กที่สุดเท่าที่จะทำได้ก่อน (string, boolean, number)
 39 | - independent ต่อกัน จะทำให้ให้จัดการง่ายที่สุด อย่างพึ่งให้ความสำคัญกับความสวยงามของโค้ด และอย่าพึ่งสร้าง abstraction ตั้งแต่เริ่มต้น
 40 | 
 41 | ในกรณีนี้เราจะสร้าง 2 state คือ `title: string` และ `content: string`
 42 | 
 43 | เปิด `index.js` ขึ้นมาแล้ว เพิ่มโค้ดนี้ลงไป
 44 | 
 45 | ```js
 46 | function App() {
 47 |   const [title, setTitle] = React.useState('');
 48 |   const [content, setContent] = React.useState('');
 49 |   return (
 50 |     <div>
 51 |       <h1 style={{ fontSize: '1.25rem' }}>Note Editor</h1>
 52 | 
 53 |       <label htmlFor="title">Title</label>
 54 |       <input id="title" />
 55 | 
 56 |       <label htmlFor="content">Content</label>
 57 |       <textarea id="content" />
 58 |     </div>
 59 |   )
 60 | }
 61 | ```
 62 | 
 63 | ทีนี้เรามาลอง refactor ให้เก็บ state ในที่เดียวกันโดยการรวม title & content เข้ามาใน note
 64 | 
 65 | ```js
 66 | const [note, setNote] = React.useState({ title: '', content: '' });
 67 | ```
 68 | 
 69 | 💡 ความยุ่งยากของการใช้ object (หรือ array) คือเวลาเราจะ setState บางส่วน เราต้องนำ state อื่นๆที่มีอยู่แล้วใส่เข้าไปด้วย 
 70 | 
 71 | ```js
 72 | setNote({ title: 'Hello' }) // การที่เรียกแบบนี้จะทำให้ content กลายเป็น undefined เมื่อเกิดการ rerender
 73 | ```
 74 | 
 75 | ดังนั้นควรเริ่มจากการเก็บ state เป็น string, boolean, number ถ้าเป็นไปได้ แล้วค่อยๆปรับให้เหมาะสมเมื่อมี requirement เพิ่มขึ้น (ไม่ต้องกังวลเรื่องการ rerender หลายครั้งโดยไม่จำเป็น เพราะส่วนใหญ่แทบจะไม่มีผลอะไรกับ users เลย)
 76 | 
 77 | ## 2nd requirement - Time travel
 78 | 
 79 | สามารถ undo, redo จากการกดปุ่มได้
 80 | 
 81 | การที่จะทำให้สามารถ undo ได้เราไม่สามารถเก็บ state เป็น string หรือ number ได้แล้ว เราต้องมี array(...) เพื่อที่จะได้ save ค่าในแต่ละจุดลงใน state ได้
 82 | 
 83 | ลองจินตนาการ history คร่าวๆ จะได้เป็นแบบนี้
 84 | 
 85 | 1. พิมพ์ `H` ในหัวข้อ -> `[{ title: 'H', content: '' }]`
 86 | 2. พิมพ์ `t` ในเนื้อหา -> `[{ title: 'H', content: 't' }]`
 87 | 3. พิมพ์ `o` ในเนื้อหา -> `[{ title: 'H', content: 'to' }]`
 88 | 
 89 | ดังนั้น state `history` ที่เราจะสร้างควรจะเป็น array ที่ในแต่ละ index จะต้องเก็บค่าต่างๆ ณ ตอนนั้นเอาไว้
 90 | 
 91 | ```js
 92 | const [history, setHistory] = React.useState([]);
 93 | 
 94 | <input id="title" onChange={event => {
 95 |   setTitle(event.target.value);
 96 |   setHistory(latestHistory => ([{ title: event.target.value, content }, ...latestHistory]))
 97 | }} />
 98 | <input id="title" onChange={event => {
 99 |   setTitle(event.target.value);
100 |   setHistory(latestHistory => ([{ title, content: event.target.value }, ...latestHistory]))
101 | }} />
102 | ```
103 | 
104 | ต่อมาเรามา implement ปุ่ม undo กัน...
105 | 
106 | ```js
107 | <button onClick={() => {
108 |   const previousNote = history[0];
109 |   if (previousNote) {
110 |     setTitle(previousNote.title);
111 |     setContent(previousNote.content);
112 |     setHistory(latestHistory => latestHistory.slice(1));
113 |   }
114 | }}>Undo</button>
115 | ```
116 | 
117 | **Challenge**
118 | ```
119 | เพิ่มฟีเจอร์ redo
120 | ```
121 | 
122 | ## 3rd requirement - Saving note
123 | 
124 | แน่นอนว่าเราคงไม่อยากให้โน้ตของเราหายไป เราจะมาสร้างปุ่มที่ใช้บันทึกโน้ตกัน
125 | 
126 | เราต้องสร้างอีก state ที่เป็น collection ของโน้ตที่เรามีอยู่ เมื่อเรากด save เราจะเพิ่มโน้ตเข้าไปใน collection จากนั้นรีเซ็ตค่าต่างๆใน editor เพื่อให้เราสามารถกรอกค่าใหม่ลงไปได้
127 | 
128 | เราจะมาปรับ layout กันนิดนึงโดยการเพิ่ม note collection ไปทางซ้ายของ editor (หากไม่เข้าไปไม่เป็นไร อันนี้เป็นเรื่องของ CSS ไม่ได้เกี่ยวกับ React)
129 | 
130 | จากนั้นเราก็เพิ่ม state `notes` และ ปุ่ม save ลงไป แล้วก็ใส่ function `onClick`.
131 | 
132 | ---
133 | 
134 | ## Homework
135 | 
136 | ### 4th requirement - Editing note
137 | 
138 | เพิ่มฟีเจอร์การแก้ไขโน้ตที่สร้างไว้แล้ว และบันทึกทับของเก่าได้
139 | 
140 | ### 5th requirement - Deleting note
141 | 
142 | เพิ่มฟีเจอร์ลบโน้ตที่อยู่ในลิสต์
143 | 
144 | ---
145 | 
146 | <div align="center">
147 |   <a href="../L02_mental-model/L02_mental-model.md">
148 |     ◀ Previous Lesson
149 |   </a>
150 |    | 
151 |   <a href="../L04_separation/L04_separation.md">
152 |     Next Lesson ▶
153 |   </a>
154 | </div>
155 | <div align="center">
156 |   <a href="../../README.md" style="font-size: 24px;">
157 |     >>> ไปหน้าสารบัญ <<<
158 |   </a>
159 | </div>
160 |

--------------------------------------------------------------------------------
/lib/normalize.css:
--------------------------------------------------------------------------------
  1 | /*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
  2 | 
  3 | /* Document
  4 |    ========================================================================== */
  5 | 
  6 | /**
  7 |  * 1. Correct the line height in all browsers.
  8 |  * 2. Prevent adjustments of font size after orientation changes in iOS.
  9 |  */
 10 | 
 11 | html {
 12 |   line-height: 1.15; /* 1 */
 13 |   -webkit-text-size-adjust: 100%; /* 2 */
 14 |   font-size: 18px;
 15 | }
 16 | 
 17 | /* Sections
 18 |    ========================================================================== */
 19 | 
 20 | /**
 21 |  * Remove the margin in all browsers.
 22 |  */
 23 | 
 24 | body {
 25 |   margin: 0;
 26 |   font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica,
 27 |     Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
 28 | }
 29 | 
 30 | /**
 31 |  * Render the `main` element consistently in IE.
 32 |  */
 33 | 
 34 | main {
 35 |   display: block;
 36 | }
 37 | 
 38 | /**
 39 |  * Correct the font size and margin on `h1` elements within `section` and
 40 |  * `article` contexts in Chrome, Firefox, and Safari.
 41 |  */
 42 | 
 43 | h1 {
 44 |   font-size: 2em;
 45 |   margin: 0.67em 0;
 46 | }
 47 | 
 48 | /* Grouping content
 49 |    ========================================================================== */
 50 | 
 51 | /**
 52 |  * 1. Add the correct box sizing in Firefox.
 53 |  * 2. Show the overflow in Edge and IE.
 54 |  */
 55 | 
 56 | hr {
 57 |   box-sizing: content-box; /* 1 */
 58 |   height: 0; /* 1 */
 59 |   overflow: visible; /* 2 */
 60 | }
 61 | 
 62 | /**
 63 |  * 1. Correct the inheritance and scaling of font size in all browsers.
 64 |  * 2. Correct the odd `em` font sizing in all browsers.
 65 |  */
 66 | 
 67 | pre {
 68 |   font-family: monospace, monospace; /* 1 */
 69 |   font-size: 1em; /* 2 */
 70 | }
 71 | 
 72 | /* Text-level semantics
 73 |    ========================================================================== */
 74 | 
 75 | /**
 76 |  * Remove the gray background on active links in IE 10.
 77 |  */
 78 | 
 79 | a {
 80 |   background-color: transparent;
 81 | }
 82 | 
 83 | /**
 84 |  * 1. Remove the bottom border in Chrome 57-
 85 |  * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
 86 |  */
 87 | 
 88 | abbr[title] {
 89 |   border-bottom: none; /* 1 */
 90 |   text-decoration: underline; /* 2 */
 91 |   text-decoration: underline dotted; /* 2 */
 92 | }
 93 | 
 94 | /**
 95 |  * Add the correct font weight in Chrome, Edge, and Safari.
 96 |  */
 97 | 
 98 | b,
 99 | strong {
100 |   font-weight: bolder;
101 | }
102 | 
103 | /**
104 |  * 1. Correct the inheritance and scaling of font size in all browsers.
105 |  * 2. Correct the odd `em` font sizing in all browsers.
106 |  */
107 | 
108 | code,
109 | kbd,
110 | samp {
111 |   font-family: monospace, monospace; /* 1 */
112 |   font-size: 1em; /* 2 */
113 | }
114 | 
115 | /**
116 |  * Add the correct font size in all browsers.
117 |  */
118 | 
119 | small {
120 |   font-size: 80%;
121 | }
122 | 
123 | /**
124 |  * Prevent `sub` and `sup` elements from affecting the line height in
125 |  * all browsers.
126 |  */
127 | 
128 | sub,
129 | sup {
130 |   font-size: 75%;
131 |   line-height: 0;
132 |   position: relative;
133 |   vertical-align: baseline;
134 | }
135 | 
136 | sub {
137 |   bottom: -0.25em;
138 | }
139 | 
140 | sup {
141 |   top: -0.5em;
142 | }
143 | 
144 | /* Embedded content
145 |    ========================================================================== */
146 | 
147 | /**
148 |  * Remove the border on images inside links in IE 10.
149 |  */
150 | 
151 | img {
152 |   border-style: none;
153 | }
154 | 
155 | /* Forms
156 |    ========================================================================== */
157 | 
158 | /**
159 |  * 1. Change the font styles in all browsers.
160 |  * 2. Remove the margin in Firefox and Safari.
161 |  */
162 | 
163 | button,
164 | input,
165 | optgroup,
166 | select,
167 | textarea {
168 |   font-family: inherit; /* 1 */
169 |   font-size: 100%; /* 1 */
170 |   line-height: 1.15; /* 1 */
171 |   margin: 0; /* 2 */
172 | }
173 | 
174 | /**
175 |  * Show the overflow in IE.
176 |  * 1. Show the overflow in Edge.
177 |  */
178 | 
179 | button,
180 | input {
181 |   /* 1 */
182 |   overflow: visible;
183 | }
184 | 
185 | /**
186 |  * Remove the inheritance of text transform in Edge, Firefox, and IE.
187 |  * 1. Remove the inheritance of text transform in Firefox.
188 |  */
189 | 
190 | button,
191 | select {
192 |   /* 1 */
193 |   text-transform: none;
194 | }
195 | 
196 | /**
197 |  * Correct the inability to style clickable types in iOS and Safari.
198 |  */
199 | 
200 | button,
201 | [type="button"],
202 | [type="reset"],
203 | [type="submit"] {
204 |   -webkit-appearance: button;
205 | }
206 | 
207 | /**
208 |  * Remove the inner border and padding in Firefox.
209 |  */
210 | 
211 | button::-moz-focus-inner,
212 | [type="button"]::-moz-focus-inner,
213 | [type="reset"]::-moz-focus-inner,
214 | [type="submit"]::-moz-focus-inner {
215 |   border-style: none;
216 |   padding: 0;
217 | }
218 | 
219 | /**
220 |  * Restore the focus styles unset by the previous rule.
221 |  */
222 | 
223 | button:-moz-focusring,
224 | [type="button"]:-moz-focusring,
225 | [type="reset"]:-moz-focusring,
226 | [type="submit"]:-moz-focusring {
227 |   outline: 1px dotted ButtonText;
228 | }
229 | 
230 | /**
231 |  * Correct the padding in Firefox.
232 |  */
233 | 
234 | fieldset {
235 |   padding: 0.35em 0.75em 0.625em;
236 | }
237 | 
238 | /**
239 |  * 1. Correct the text wrapping in Edge and IE.
240 |  * 2. Correct the color inheritance from `fieldset` elements in IE.
241 |  * 3. Remove the padding so developers are not caught out when they zero out
242 |  *    `fieldset` elements in all browsers.
243 |  */
244 | 
245 | legend {
246 |   box-sizing: border-box; /* 1 */
247 |   color: inherit; /* 2 */
248 |   display: table; /* 1 */
249 |   max-width: 100%; /* 1 */
250 |   padding: 0; /* 3 */
251 |   white-space: normal; /* 1 */
252 | }
253 | 
254 | /**
255 |  * Add the correct vertical alignment in Chrome, Firefox, and Opera.
256 |  */
257 | 
258 | progress {
259 |   vertical-align: baseline;
260 | }
261 | 
262 | /**
263 |  * Remove the default vertical scrollbar in IE 10+.
264 |  */
265 | 
266 | textarea {
267 |   overflow: auto;
268 | }
269 | 
270 | /**
271 |  * 1. Add the correct box sizing in IE 10.
272 |  * 2. Remove the padding in IE 10.
273 |  */
274 | 
275 | [type="checkbox"],
276 | [type="radio"] {
277 |   box-sizing: border-box; /* 1 */
278 |   padding: 0; /* 2 */
279 | }
280 | 
281 | /**
282 |  * Correct the cursor style of increment and decrement buttons in Chrome.
283 |  */
284 | 
285 | [type="number"]::-webkit-inner-spin-button,
286 | [type="number"]::-webkit-outer-spin-button {
287 |   height: auto;
288 | }
289 | 
290 | /**
291 |  * 1. Correct the odd appearance in Chrome and Safari.
292 |  * 2. Correct the outline style in Safari.
293 |  */
294 | 
295 | [type="search"] {
296 |   -webkit-appearance: textfield; /* 1 */
297 |   outline-offset: -2px; /* 2 */
298 | }
299 | 
300 | /**
301 |  * Remove the inner padding in Chrome and Safari on macOS.
302 |  */
303 | 
304 | [type="search"]::-webkit-search-decoration {
305 |   -webkit-appearance: none;
306 | }
307 | 
308 | /**
309 |  * 1. Correct the inability to style clickable types in iOS and Safari.
310 |  * 2. Change font properties to `inherit` in Safari.
311 |  */
312 | 
313 | ::-webkit-file-upload-button {
314 |   -webkit-appearance: button; /* 1 */
315 |   font: inherit; /* 2 */
316 | }
317 | 
318 | /* Interactive
319 |    ========================================================================== */
320 | 
321 | /*
322 |  * Add the correct display in Edge, IE 10+, and Firefox.
323 |  */
324 | 
325 | details {
326 |   display: block;
327 | }
328 | 
329 | /*
330 |  * Add the correct display in all browsers.
331 |  */
332 | 
333 | summary {
334 |   display: list-item;
335 | }
336 | 
337 | /* Misc
338 |    ========================================================================== */
339 | 
340 | /**
341 |  * Add the correct display in IE 10+.
342 |  */
343 | 
344 | template {
345 |   display: none;
346 | }
347 | 
348 | /**
349 |  * Add the correct display in IE 10.
350 |  */
351 | 
352 | [hidden] {
353 |   display: none;
354 | }
355 |

--------------------------------------------------------------------------------
/lessons/L02_mental-model/L02_mental-model.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 |   <a href="../L01_introduction/L01_introduction.md">
  3 |     ◀ Previous Lesson
  4 |   </a>
  5 |    | 
  6 |   <a href="../L03_managing-state/L03_managing-state.md">
  7 |     Next Lesson ▶
  8 |   </a>
  9 | </div>
 10 | <div align="center">
 11 |   <a href="../../README.md" style="font-size: 24px;">
 12 |     >>> ไปหน้าสารบัญ <<<
 13 |   </a>
 14 | </div>
 15 | 
 16 | # บทเรียน 2 - Mental Model
 17 | 
 18 | > Video ประกอบการสอน: [https://www.youtube.com/watch?v=kFFBREQGtYA](https://www.youtube.com/watch?v=kFFBREQGtYA&list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr)
 19 | 
 20 | สำหรับท่านใดที่ยังไม่เคยใช้งาน React มาก่อน ผมอยากให้ลองทำ
 21 | 
 22 | 1. [Official Tutorial](https://reactjs.org/tutorial/tutorial.html): ในตัวอย่างเค้าจะใช้เป็น class component
 23 | 2. [Hooks at a Glance](https://reactjs.org/docs/hooks-overview.html) เพื่อปูพื้นฐาน react hook
 24 | 
 25 | เพราะว่าผมจะไม่อธิบายพื้นฐานมากนัก. ส่วนท่านใดที่มีพื้นฐาน React อยู่แล้ว เรามาเริ่มกันเลยครับ...
 26 | 
 27 | ---
 28 | 
 29 | Mental model แปลแบบบ้านๆคือ สื่งที่เกิดขึ้นในหัวของเราเวลาอ่านโค้ด แต่ละคนอาจมีกระบวนการคิด หรือ วิธีการมองที่แตกต่างกันออกไป เช่น บางคนอ่านโค้ดจากบนไปล่าง บางคนอ่านที่ละฟังก์ชั่น บางคนตีความออกเป็นภาพในหัว
 30 | 
 31 | หากเรามี mental model ที่ดี จะช่วยทำให้เราทำความเข้าใจโค้ดและเชื่อมโยงได้เร็วมากขึ้น
 32 | 
 33 | สำหรับบทเรียนนี้ผมจะแนะนำ mental model ที่ผมใช้แล้วรู้สึกว่าเวิคมากกับการเขียน functional component ใน React, ผมขอเรียกมันว่า snapshot mental model หรือจะเรียกว่าเป็นการมองแบบเป็นฉากก็ได้. ในแต่ละฉากเปรียบเสมือนเราถ่ายรูปของข้อมูลไว้รวมถึง UI ที่จะเกิดขึ้นด้วยแล้วส่งให้กับ React จากนั้น React จะการันตีว่าสิ่งที่ปรากฎขึ้นบนหน้าจอนั้นจะตรงกัน และเมื่อข้อมูลมีการเปลี่ยนแปลงก็จะทำให้เกิด snapshot (รูปถ่าย) **ขึ้นมาใหม่**. สิ่งที่ปรากฎบนหน้าจอจะเป็น snapshot อันล่าสุดเสมอ.
 34 | 
 35 | > ถ้าติดตั้ง serve ผ่าน yarn หรือ npm แล้ว ให้รัน `serve` ใน terminal ที่ root folder นี้
 36 | > จากนั้นไปที่ localhost ตามที่ปรากฎบน terminal แล้วเลือก `/lessons/L02_mental-model/`
 37 | 
 38 | ### ตัวอย่างที่ 1 - counter
 39 | 
 40 | ```js
 41 | import React from 'react';
 42 | 
 43 | function Counter() {
 44 |   const [count, setCount] = React.useState(0);
 45 |   return (
 46 |     <div>
 47 |       <span>{count}</span>
 48 |       <button onClick={() => setCount(count + 1)}>increment</button>
 49 |     </div>
 50 |   )
 51 | }
 52 | ```
 53 | 
 54 | ผมจะอธิบายผ่านภาพที่เกิดขึ้นในหัวของผมนะครับ. หลักการคือให้เรา snapshot ค่าต่างๆของเอาไว้ก่อนที่จะ render ในแต่ละครั้ง เพราะใน functional component ค่าต่างๆจะถูกสร้างขึ้นมาใหม่เมื่อมีการ (re)render ยกเว้นค่าที่เกิดจาก React APIs. ในแต่ละ snapshot ที่เกิดขึ้น React จะการันตีว่าสิ่งที่เกิดขึ้นบนหน้าจอนั้นสอดคล้องกับค่าต่างๆใน snapshot นั้นๆ
 55 | 
 56 | **Snapshot 0**
 57 | 
 58 | ฉากแรกของทุกๆ component คือฉากก่อนที่จะ render ลงบนหน้าจอ. เมื่อเราเรียกใช้ [`React.useState(0)`](https://reactjs.org/docs/hooks-reference.html#usestate) React จะสร้าง internal state ไว้ภายใน ซึ่งในตัวอย่างผมตั้งชื่อไว้ว่า `count`.
 59 | 
 60 | ![image](https://user-images.githubusercontent.com/18292247/146857334-7cf5e6a5-4dbc-414f-84ac-4b82a325197b.png)
 61 | 
 62 | **Snapshot 1**
 63 | 
 64 | เมื่อผมกดปุ่ม `increment`:
 65 | 
 66 | 1. ฟังกชั่นที่อยู่ใน `onClick` จะทำงาน
 67 | 2. `setCount` ถูกเรียก
 68 | 3. React นำ `(0 + 1)` เข้าไปใน state update queue
 69 | 4. React ทำการ update state
 70 | 
 71 | เราจะได้หน้าตาของ snapshot 1 เป็นแบบนี้
 72 | 
 73 | ![image](https://user-images.githubusercontent.com/18292247/146858231-63a74c20-ad7f-49b7-b2a9-2005f6d91c3d.png)
 74 | 
 75 | 
 76 | 5. React สั่งให้ browser render โดยใช้ค่าจาก snapshot 1
 77 | 
 78 | ✍️ **Challenge**
 79 | ```
 80 | ให้เขียนสิ่งที่เกิดขึ้นและวาด Snapshot 2 เมื่อกดปุ่ม increment อีกครั้ง
 81 | ```
 82 | สามารถวาดลงบนบราวเซอร์ผ่าน [Exclaridraw](https://excalidraw.com/) ได้.
 83 | 
 84 | ### ตัวอย่างที่ 2 - Search
 85 | 
 86 | เราเริ่มมาดูตัวอย่างที่ใกล้เคียงกับความเป็นจริงเพิ่มขึ้น เราจะมีตารางที่ users สามารถค้นหาจากชื่อได้
 87 | 
 88 | ```js
 89 | import React from 'react';
 90 | 
 91 | const MEMBERS = [
 92 |   { name: 'Tony Stark', level: 20, alive: false },
 93 |   { name: 'Captain', level: 99, alive: true },
 94 |   { name: 'Ant man', level: 38, alive: true },
 95 | ]
 96 | 
 97 | function MemberTable() {
 98 |   // TODO: ควรจะมี state อะไรเก็บไว้บ้าง หากต้องการให้ค้นหาชื่อได้
 99 |   return (
100 |     <div>
101 |       <input placeholder="พิมชื่อเพื่อค้นหา..." />
102 |       {MEMBERS.map(member => (
103 |         <div style={{ display: 'flex' }}>
104 |           <div style={{ flexBasis: '40%' }}>{member.name}</div>
105 |           <div style={{ flexBasis: '30%' }}>{member.level}</div>
106 |           <div style={{ flexBasis: '30%' }}>{member.alive}</div>
107 |         </div>
108 |       )}
109 |     </div>
110 |   )
111 | }
112 | ```
113 | 
114 | ✍️ **Challenge**
115 | แก้ตรง TODO ให้เป็น `useState`.
116 | 
117 | อย่างในเคสนี้ state คือ**ชื่อ**ที่ users ต้องการจะค้นหา
118 | 
119 | ```js
120 | const [searchText, setSearchText] = React.useState('');
121 | ```
122 | 
123 | จากนั้นเชื่อม state เข้ากับ event handler (หากไม่เข้าใจโค้ด ไม่ต้องกังวล ทำตามไปก่อนนะครับ)
124 | 
125 | ```js
126 | import React from 'react';
127 | 
128 | const MEMBERS = [
129 |   { name: 'Tony Stark', level: 20, alive: false },
130 |   { name: 'Captain', level: 99, alive: true },
131 |   { name: 'Ant man', level: 38, alive: true },
132 | ]
133 | 
134 | function MemberTable() {
135 |   const [searchText, setSearchText] = React.useState('');
136 |   const filteredMembers = MEMBERS.filter(item => item.name.includes(searchText));
137 |   return (
138 |     <div>
139 |       <input placeholder="พิมชื่อเพื่อค้นหา..." value={searchText} onChange={e => setSearchText(e.target.value)} />
140 |       {filteredMembers.map(member => (
141 |         <div style={{ display: 'flex' }}>
142 |           <div style={{ flexBasis: '40%' }}>{member.name}</div>
143 |           <div style={{ flexBasis: '30%' }}>{member.level}</div>
144 |           <div style={{ flexBasis: '30%' }}>{member.alive}</div>
145 |         </div>
146 |       )}
147 |     </div>
148 |   )
149 | }
150 | ```
151 | 
152 | **Snapshot 0**
153 | 
154 | ตัวแปรของเราตอนนี้มีอยู่ 2 ตัว `searchText` และ `filteredMembers`
155 | 
156 | ![image](https://user-images.githubusercontent.com/18292247/147025404-4cd06eaa-c0cd-4b75-9c83-2ad93cb91811.png)
157 | 
158 | **Snapshot 1**
159 | 
160 | เมื่อผม copy `ta` และแปะลงใน input:
161 | 
162 | 1. ฟังกชั่นที่อยู่ใน `onChange` จะทำงาน
163 | 2. `setSearchText` ถูกเรียก
164 | 3. React นำ `e.target.value` ซึ่งคือ `'ta'` เข้าไปใน state update queue
165 | 4. React ทำการ update state
166 | 
167 | เราจะได้หน้าตาของ snapshot 1 เป็นแบบนี้
168 | 
169 | ![image](https://user-images.githubusercontent.com/18292247/147025810-3af3e220-9962-4993-8075-f5ded22caa83.png)
170 | 
171 | ✍️ **Challenge**
172 | ```
173 | ให้วาด Snapshot 2 เมื่อพิมตัวอักษร `i` ต่อจากที่มีอยู่
174 | ```
175 | สามารถวาดลงบนบราวเซอร์ผ่าน [Exclaridraw](https://excalidraw.com/) ได้.
176 | 
177 | ✍️ **Challenge**
178 | ```
179 | แก้ logic ตรง filter ให้เป็น case insensitive. ถ้าพิม `s` ตัวเล็ก ต้องแสดง Tony Stark อันเดียว
180 | ```
181 | 
182 | ### ตัวอย่างที่ 3 - magic counter
183 | 
184 | ```js
185 | import React from 'react';
186 | 
187 | function Counter() {
188 |   const [count, setCount] = React.useState(0);
189 |   return (
190 |     <div>
191 |       <span>{count}</span>
192 |       <button onClick={() => {
193 |         setCount(count + 1);
194 |         setTimeout(() => {
195 |           setCount(count + 1);
196 |         }, [3000])
197 |       }}>increment</button>
198 |     </div>
199 |   )
200 | }
201 | ```
202 | 
203 | ส่วนใหญ่แล้วความยากของการเขียน React จะเกิดขึ้นเมื่อเราต้องยุ่งกับ asynchronous task เช่น `setTimeout` เป็นต้น.
204 | 
205 | **Question**
206 | จากตัวอย่างด้านบน ถ้ากด `increment` หนึ่งครั้ง แล้วรอไปอีก 3 วินาที สุดท้ายแล้วจะเห็นค่า count บนหน้าจอเป็นเท่าไหร่?
207 | 
208 | ทำไมถึงได้คำตอบเช่นนั้น เนื่องจากว่า function ถือว่าเป็นส่วนหนึ่งใน snapshot ด้วย ในแต่ละ snapshot จะมีค่าไม่เหมือนกัน
209 | 
210 | **Snapshot 0** (หลังจากการ render แล้ว)
211 | 
212 | ![image](https://user-images.githubusercontent.com/18292247/147389006-732ec2b2-651b-4fe9-8c87-cd54deffab66.png)
213 | 
214 | จะเห็นว่าเราสามารถนำค่า count เข้าไปแทนค่าตัวแปรใน function ได้เลย
215 | 
216 | เมื่อผมกดปุ่ม `increment`:
217 | 
218 | 1. ฟังกชั่นที่อยู่ใน `onClick` จะทำงาน
219 | 2. `setCount` ถูกเรียก
220 | 3. function ใน `setTimeout` เข้า microtask queue
221 | 4. React ทำการ update state ของ count เป็น 1
222 | 5. Counter เกิดการ rerender ด้วยค่า count = 1
223 | 6. ค่า 1 แสดงบนหน้าจอ
224 | 7. 3 วินาทีผ่านไป `() => { setCount(0 + 1) }` ถูกเรียกซึ่งผลลัพธ์มีค่าเท่ากับ state ณ ตอนนั้น react จึงไม่ทำอะไร
225 | 
226 | แล้วถ้าเราต้องการใช้ค่าล่าสุดใน `setTimeout` ต้องทำอย่างไร?
227 | 
228 | React มีวิธีให้เราอ่านค่าล่าสุดของ state ได้ โดยใช้ callback ใน `setState` อย่างเช่นในกรณีนี้เราต้องการให้ค่า count เพิ่มขึ้นอีกหนึ่งหลังจาก timeout เราจะเขียนได้แบบนี้
229 | 
230 | ```js
231 | setTimeout(() => {
232 |   // latestCount คือค่าล่าสุด เราไม่สามารถบอกได้แน่นอนว่ามีค่าเท่าไหร่
233 |   // เพราะ ค่า latestCount อาจถูกเปลี่ยนแปลงมาจากที่อื่น แต่ React จะการันตีว่า
234 |   // ณ ตอนนี้ `setCount` ถูกเรียก React จะส่งค่า state ล่าสุดมาให้เราใน callback
235 |   setCount(latestCount => latestCount + 1);
236 | }, [3000])
237 | ```
238 | 
239 | ---
240 | 
241 | ## การบ้านท้ายบท
242 | 
243 | โค้ดอยู่ใน `./homework.js`, ให้ uncomment homework script ใน `index.html` เพื่อแสดงผลบน browser
244 | 
245 | ```html
246 | <body>
247 |   
248 | 
249 |   
250 |   <script type="text/babel" data-type="module" src="./homework.js"></script>
251 | </body>
252 | ```
253 | 
254 | จากนั้น save แล้ว refresh บน browser อีกครั้ง
255 | 
256 | ---
257 | 
258 | <div align="center">
259 |   <a href="../L01_introduction/L01_introduction.mdd">
260 |     ◀ Previous Lesson
261 |   </a>
262 |    | 
263 |   <a href="../L03_managing-state/L03_managing-state.md">
264 |     Next Lesson ▶
265 |   </a>
266 | </div>
267 | <div align="center">
268 |   <a href="../../README.md" style="font-size: 24px;">
269 |     >>> ไปหน้าสารบัญ <<<
270 |   </a>
271 | </div>
272 |

--------------------------------------------------------------------------------
/lessons/L01_introduction/L01_introduction.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 |   <a href="../L00_getting-started/L00_getting-started.md">
  3 |     ◀ Previous Lesson
  4 |   </a>
  5 |    | 
  6 |   <a href="../L02_mental-model/L02_mental-model.md">
  7 |     Next Lesson ▶
  8 |   </a>
  9 | </div>
 10 | <div align="center">
 11 |   <a href="../../README.md" style="font-size: 24px;">
 12 |     >>> ไปหน้าสารบัญ <<<
 13 |   </a>
 14 | </div>
 15 | 
 16 | # บทเรียน 1 - ประวัติศาสตร์, ปัจจุบัน และ อนาคต
 17 | 
 18 | > Video ประกอบการสอน: [https://www.youtube.com/watch?v=gglRX8qsJus](https://www.youtube.com/watch?v=gglRX8qsJus&list=PLLPNfc7CgMywiG-R6Jix_w8zqF_fxZFxr)
 19 | 
 20 | การเรียนรู้ประวัติศาสตร์เป็นจุดเริ่มต้นที่สำคัญที่จะทำให้เราเข้าใจว่า React นั้นเกิดขึ้นมาเพื่อจุดประสงค์อะไร คนที่สร้าง React ต้องการแก้ปัญหาอะไร และทำไม React ถึงได้ถูกออกแบบมาในลักษณะนี้
 21 | 
 22 | เมื่อเราเข้าใจถึงที่มาที่ไปของ React แล้ว ผมเชื่อว่า
 23 | 
 24 | 1. นำ React ไปใช้ได้ถูกสถานการณ์ เพราะ React ก็ถือว่าเป็นเครื่องมือชิ้นหนึ่ง เราควรใช้เครื่องมือให้เหมาะกับปัญหาด้วย
 25 | 2. สร้างรากฐานที่ดี อาจทำให้เกิดจังหวะปิ๊งป่องได้ในอนาคต เวลาเจอเคสที่ซับซ้อนมากขึ้น
 26 | 3. เมื่อมองเห็นภาพรวมของการเปลี่ยนแปลง และ API ที่เปลี่ยนไป จะทำให้เราสามารถนำไปประยุกต์ต่อยอด สร้างสิ่งใหม่ๆได้
 27 | 
 28 | ## ประวัติศาสตร์
 29 | 
 30 | เราจะย้อนกลับไปในช่วงก่อนปี 2010 ซึ่ง React ยังไม่เกิดนะครับ ช่วงนั้นเนี่ยเราจะเห็นว่ามี js framework ต่างๆมากมาย เราจะได้ยินคำนี้เยอะมากนะครับ MVC, MVVM, MVW แต่ไม่ว่าจะเป็น M อะไรก็ตาม สิ่งที่คล้ายกันก็คือการสร้าง observable object ที่สามารถ subscribe ได้ จากนั้นถ้า data เปลี่ยน เราก็จะทำการเปลี่ยนรูป หรือ mutate view 
 31 | 
 32 | key สำคัญอยู่ที่คำว่า Mutation เวลาที่แอพของเราใหญ่ขึ้นเรื่อยๆ การ mutate(ในเคสของ UI คือ DOM) อะไรก็ตามจะยิ่งเพิ่ม complexity และทำให้เราคาดเดาผลลัพธ์ที่จะเกิดขึ้นได้ยากขึ้น ทีนี้ก็เลยมีคนคิดไอเดียนี้ขึ้นมา what if? ถ้าหากว่าเราไม่ mutate แต่สร้างใหม่ทุกครั้งเมื่อ data เปลี่ยนล่ะ ?? หืมมม...จะเวิคหรอ ในตอนนั้นมันดูเป็นไอเดียที่แย่มากเพราะว่าการสร้าง DOM ขึ้นมาใหม่นั้นดูไม่น่าเป็นไปได้เลย เช่น ถ้าตอนนั้น user กำลังพิมอยู่แล้วเราไป render view ใหม่ทับเข้าไป ux ไม่ดีแน่นอน ...โอเค ถ้างั้นเราไม่ยุ่งกับ DOM แต่เราจะโยนหน้าที่นี้ไปให้ javascript แทน แน่นอนว่าก็ยังมีข้อสงสัยอยู่ว่า performance มันจะต้องแย่แน่นอนเลยเพราะว่า ทุกๆครั้งที่ data เปลี่ยน เราจะต้องสร้าง tree ที่แสดงถึง view อันใหม่ขึ้นมา แล้วเอามาเทียบกับของเก่า เพื่อจะหาว่ามีจุดไหนเปลี่ยนบ้าง แล้วค่อยไล่ mutate DOM อีกที ...แต่ปรากฏว่า javascript นั้นเร็วมากๆ ซึ่งสุดท้ายแล้วมันเวิค ถึงจุดนี้ผมคิดว่าคงมีบางท่านที่เริ่มคุ้นๆกับสิ่งที่ผมเล่าให้ฟังบ้างแล้วนะครับ ถูกต้องครับ ต่อมามันมีชื่อว่า Virtual DOM นั่นเอง และนี่ก็คือที่มีของการเปลี่ยนจาก mutation มาเป็น rerender
 33 |   
 34 | แน่นอนครับไอเดียนี้ไม่ได้มาจากผมแน่นอน แต่เป็นคนนี้ครับ Jordan Walke ตอนนั้นเป็น engineer อยู่ที่ facebook ทำในส่วนของ facebook ads เป็นหลัก และด้วยความที่เค้าชื่นชอบ functional programming มาก จึงมีอิทธิพลทำให้ react มี API ออกไปทาง functional programming
 35 | 
 36 | ด้วยเหตุผลนี้เอง แนวคิดของ React จึงเปลี่ยนจาก Mutation มาเป็น Reconciliation หรือแปลเป็นไทยได้ว่า กระบวนการเปรียนเทียบความแตกต่าง (diffing algorithm)
 37 | 
 38 | Reconciliation ทำให้ React เป็นที่ชื่นชอบของโปรแกรมเมอร์มากๆ เพราะว่า จากที่เราต้องจัดการ DOM ด้วยตัวเอง เราโยนหน้าที่นั้นให้ React จัดการ โดย React ปล่อยให้เราควบคุม logic ของ application ที่เราต้องการ จากนั้นส่งผลลัพธ์ที่เราคาดหวังไปให้กับ React ในรูปของ JSX จากนั้น React จะเป็นคนจัดการงานในส่วนของการอัพเดท UI บนหน้าจอให้กับเรา เมื่อข้อมูลมีการเปลี่ยนแปลง React จะการันตีว่าสิ่งที่แสดงผลบนหน้าจอนั้นตรงกับผลลัพธ์ที่ส่งไปให้ล่าสุด
 39 | 
 40 | **Challenge**
 41 | ```
 42 | ลองสร้าง Todo App ง่ายๆ ด้วย javascript โดยไม่พึ่ง library อะไรเลย
 43 | ```
 44 | 
 45 | ...เรามาเริ่มมาดูหน้าตาของ React กัน
 46 | 
 47 | ### ยุคเริ่มต้น
 48 | 
 49 | ในการเขียน UI แน่นอนว่าจะต้องมีสิ่งที่ user สามารถสื่อสารกับ application ของเราได้ ใน React เราจะเรียกข้อมูลนั้นว่า state เช่น ข้อความที่ user พิมลงใน input หากเราต้องการนำข้อความนั้นมาประมวลผล เราจะสามารถเก็บข้อความนั้นเป็น state อยู่ภายใน React component ได้ ซึ่งในช่วงแรกๆ (ก่อน React v16.8) เราจะเขียน React component ในรูปแบบของ class เป็นส่วนใหญ่ เนื่องจาก ณ ตอนนั้น functional component ยังไม่สามารถเก็บ state ภายในตัวเองได้
 50 | 
 51 | > ในคอร์สนี้เราจะใช้แต่ functional component เท่านั้น เพราะในปัจจุบันแทบจะไม่มีใครเขียน class component แล้ว ส่วนเหตุผลเดี๋ยวเราไปดูในตอนหน้ากัน
 52 | 
 53 | React เริ่มจากการเป็น library เล็กๆที่ใช้ในการสร้าง UI ดังนั้นในยุคแรกๆ เราจะเห็นว่ามี libraries ใน ecosystem ต่างๆเกิดขึ้นมากมายเพื่อมา support react อย่างเช่น
 54 | 
 55 | - `react-router`: ใช้ในการจัดการ routing
 56 | - `react-redux`: เชื่อม redux ซึ่งใช้จัดการ global state
 57 | - `react-motion`: ใช้สร้าง animation
 58 | 
 59 | นับตั้งแต่นั้น react ก็เริ่มได้รับความนิยมมากขึ้น เนื่องมาจาก
 60 | 	• concept ที่แตกต่าง แต่เข้าใจได้ง่าย
 61 | 	• สามารถนำไปใช้ได้กับโปรเจคที่มีอยู่แล้ว ไม่ว่าจะเป็น PHP หรือ JS framework อื่นๆ
 62 | 	• maintain โดย facebook มีการพัฒนาอยู่ตลอดเวลา
 63 | 
 64 | จุดที่น่าสนใจเกิดขึ้นในปี 2015, ทาง react team ได้ปล่อย major change v0.14 ออกมา ซึ่งสิ่งที่สำคัญก็คือการแยก react ออกจาก react-dom
 65 | 
 66 | สาเหตุที่แยกออกมาเนื่องจากว่าช่วงนั้นเริ่มมี library react ออกมาเพิ่มขึ้น เช่น react-native, react-art, react-canvas, and react-three มันเริ่มทำให้เห็นการทำงานที่ชัดเจนมากขึ้น เพราะ library พวกนี้รวมถึง react-dom เกี่ยวข้องกับการ render ทั้งสิ้น แค่ใช้ใน platform ที่แตกต่างกัน
 67 | 
 68 | react team ก็เลยตัดสินใจแยก react core ที่เก็บ Reconciliation algorithm ไว้ ออกมาเป็น standalone package ที่ชื่อ react ผลที่ตามมาคือ คำว่า virtual dom ก็จะหายไปด้วย เพราะว่าสิ่งที่อยู่ใน package react ไม่ได้มีอะไรเกี่ยวข้องกับ DOM อีกต่อไป
 69 | 
 70 | ### จุดเปลี่ยนที่สำคัญ
 71 | 
 72 | ประมาณปี 2017, React v15 เริ่มจนมุม เนื่องจาก
 73 | 	• feature ที่ community request อย่างเช่น render เป็น array ได้ หรือการใช้ <Fragment />
 74 | 	• ErrorBoundary ที่มีอยู่ครึ่งๆกลางๆ แทบจะไม่มีใครรู้ว่ามี
 75 | 	• ที่สำคัญที่สุดคือเรื่อง Performance limitation ที่ไม่สามารถรองรับการคำนวณใหญ่ๆได้ (React อัพเดท UI ไม่ทัน)
 76 |   
 77 | ผมคงจะไม่อธิบายถึงรายละเอียด แต่โดยสรุปคือ React v15 นั้นถูกเขียนขึ้นในลักษะ synchronous หมายความว่า React ได้รับคำสั่งอะไรมาก็จะทำตามให้เสร็จทันทีจากนั้นค่อยทำงานที่อยู่ในคิวต่อไป
 78 | 
 79 | ดังนั้นถ้าเกิดมีงานเกิดขึ้นเยอะเกินไป (รวมถึงขนาดของงานด้วย) เช่น user พิมข้อความใน input และแต่ละตัวอักษรมีการคำนวณเกิดขึ้นเป็นแสนๆ loop ก่อนที่ React จะสามารถอัพเดทผลลัพธ์บนหน้าจอได้ จะทำให้ user รู้สึกถึงความหน่วงเวลาพิม, lag หรือบางครั้งอาจค้างไปเลยก็ได้ เพราะ React ไม่ฉลาดเพียงพอ
 80 | 
 81 | ทางทีม React เลยจำเป็นต้องเขียน react ขึ้นมาใหม่ใน v16 เพื่อให้โครงสร้างการทำงานของ React นั้นรองรับการทำงานแบบ asynchronous ได้ และใน React v18 ที่กำลังจะมาถึงนี้ ประมาณต้นปี 2022 จะมีการทำงานเป็น asynchronous เป็นค่าพื้นฐานเลย
 82 | 
 83 | ### อีกหนึ่งจุดเปลี่ยนสำคัญ
 84 | 
 85 | คือ v16.8 ซึ่ง React team ได้นำเสนอสิ่งที่เรียกว่า react hook ที่ทำให้ functional component สามารถเก็บ state ได้ นับว่าเปลี่ยนการเขียน React แบบเดิมๆไปจาก class component ไปเลย เพราะการเขียนเป็น react hook มีข้อดีคร่าวๆ ดังนี้:
 86 | 
 87 | - ทำให้โค้ดอ่านง่ายขึ้น
 88 | - สร้าง logic ที่สามารถทำไปใช้งานได้หลายๆที่โดยไม่ทำให้เกิด HOC hell
 89 |   ```js
 90 |   export default withAuth(withUser(withWTF(YourComponent)))
 91 |   ```
 92 | 
 93 | > ปล. class component ไม่ได้หายไปนะ ยังมีบางเคสที่ต้องใช้ class อย่างเช่น [Document component](https://github.com/vercel/next.js/blob/8b12b174e50209b0c71e3dd588c7a0871fe79598/packages/next/pages/_document.tsx?_pjax=%23js-repo-pjax-container%2C%20div%5Bitemtype%3D%22http%3A%2F%2Fschema.org%2FSoftwareSourceCode%22%5D%20main%2C%20%5Bdata-pjax-container%5D#L164) ใน NextJS เป็นต้น
 94 | 
 95 | ## อนาคต
 96 | 
 97 | ใน version 18 ที่กำลังจะมาถึงนี้เรียกได้ว่าเป็นจุดเริ่มต้นของ React ยุคใหม่เลยก็ว่าได้ เพราะการที่ React ทำงานในโหมด asynchronous ได้ ทั้งใน client & servide side จะเปิดโอกาสให้เราสามารถสร้าง UX ที่ดีมากๆให้กับทั้ง user และ โปรแกรมเมอร์ ได้ เช่น
 98 | 
 99 | - การลด bundle size ให้เล็กที่สุด ไม่ว่าจะใช้ Server component หรือ lazy + Suspense
100 | - แพคเก็จ react ใหม่ๆ เช่น react-fetch, react-cache ที่ใช้ในการทำ data fetching ที่มีประสิทธิภาพสูง
101 | - เครื่องมือสำหรับ developer เช่น react devtools ที่สามารถ track การทำงานในโหมด asynchronous ได้
102 | - ทำให้เราควบคุมการจัดลำดับงาน และบอก React ได้ว่างานไหนสำคัญ ผ่าน [startTransition API](https://reactjs.org/docs/concurrent-mode-patterns.html#transitions)
103 | 
104 | ---
105 | 
106 | 📚 อ้างอิง
107 | 
108 | - https://indepth.dev/in-depth-explanation-of-state-and-props-update-in-react/
109 | - https://indepth.dev/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber
110 | - [[JSConfUS 2013] Tom Occhino and Jordan Walke: JS Apps at Facebook](https://www.youtube.com/watch?v=GW0rj4sNH2w&t=186s)
111 | - [006 - Origins of React](https://www.youtube.com/watch?v=yiCnfJ1rflI&t=1759s)
112 | - [Introduction to React.js](https://www.youtube.com/watch?v=XxVg_s8xAms)
113 | - [Pete Hunt - The Secrets of React's Virtual DOM (FutureJS 2014)](https://www.youtube.com/watch?v=-DX3vJiqxm4&t=1s)
114 | - https://reactjs.org/blog/2015/10/07/react-v0.14.html#changelog
115 | - [Andrew Clark: What's Next for React — ReactNext 2016](https://www.youtube.com/watch?v=aV1271hd9ew)
116 | - https://github.com/acdlite/react-fiber-architecture
117 | - https://indepth.dev/inside-fiber-in-depth-overview-of-the-new-reconciliation-algorithm-in-react/
118 | - [Lin Clark - A Cartoon Intro to Fiber - React Conf 2017](https://www.youtube.com/watch?v=ZCuYPiUIONs)
119 | - [SMOOSHCAST: React Fiber Deep Dive with Dan Abramov](https://www.youtube.com/watch?v=aS41Y_eyNrU)
120 | - [Why, What, and How of React Fiber with Dan Abramov and Andrew Clark](https://www.youtube.com/watch?v=crM1iRVGpGQ)
121 | - [Brief Overview of React Fiber - A Tutorial on its Features and Advantages](https://www.youtube.com/watch?v=0fUmOPQUv-Q)
122 | - https://reactjs.org/docs/codebase-overview.html#fiber-reconciler
123 | - https://reactjs.org/docs/implementation-notes.html
124 | - https://reactjs.org/docs/design-principles.html
125 | 
126 | ---
127 | 
128 | <div align="center">
129 |   <a href="../L00_getting-started/L00_getting-started.md">
130 |     ◀ Previous Lesson
131 |   </a>
132 |    | 
133 |   <a href="../L02_mental-model/L02_mental-model.md">
134 |     Next Lesson ▶
135 |   </a>
136 | </div>
137 | <div align="center">
138 |   <a href="../../README.md" style="font-size: 24px;">
139 |     >>> ไปหน้าสารบัญ <<<
140 |   </a>
141 | </div>
142 |

--------------------------------------------------------------------------------
/lib/react.development.js:
--------------------------------------------------------------------------------
   1 | /** @license React v17.0.2
   2 |  * react.development.js
   3 |  *
   4 |  * Copyright (c) Facebook, Inc. and its affiliates.
   5 |  *
   6 |  * This source code is licensed under the MIT license found in the
   7 |  * LICENSE file in the root directory of this source tree.
   8 |  */
   9 | (function (global, factory) {
  10 |   typeof exports === "object" && typeof module !== "undefined"
  11 |     ? factory(exports)
  12 |     : typeof define === "function" && define.amd
  13 |     ? define(["exports"], factory)
  14 |     : ((global = global || self), factory((global.React = {})));
  15 | })(this, function (exports) {
  16 |   "use strict";
  17 | 
  18 |   // TODO: this is special because it gets imported during build.
  19 |   var ReactVersion = "17.0.2";
  20 | 
  21 |   // ATTENTION
  22 |   // When adding new symbols to this file,
  23 |   // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
  24 |   // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
  25 |   // nor polyfill, then a plain number is used for performance.
  26 |   var REACT_ELEMENT_TYPE = 0xeac7;
  27 |   var REACT_PORTAL_TYPE = 0xeaca;
  28 |   exports.Fragment = 0xeacb;
  29 |   exports.StrictMode = 0xeacc;
  30 |   exports.Profiler = 0xead2;
  31 |   var REACT_PROVIDER_TYPE = 0xeacd;
  32 |   var REACT_CONTEXT_TYPE = 0xeace;
  33 |   var REACT_FORWARD_REF_TYPE = 0xead0;
  34 |   exports.Suspense = 0xead1;
  35 |   var REACT_SUSPENSE_LIST_TYPE = 0xead8;
  36 |   var REACT_MEMO_TYPE = 0xead3;
  37 |   var REACT_LAZY_TYPE = 0xead4;
  38 |   var REACT_BLOCK_TYPE = 0xead9;
  39 |   var REACT_SERVER_BLOCK_TYPE = 0xeada;
  40 |   var REACT_FUNDAMENTAL_TYPE = 0xead5;
  41 |   var REACT_SCOPE_TYPE = 0xead7;
  42 |   var REACT_OPAQUE_ID_TYPE = 0xeae0;
  43 |   var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
  44 |   var REACT_OFFSCREEN_TYPE = 0xeae2;
  45 |   var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
  46 | 
  47 |   if (typeof Symbol === "function" && Symbol.for) {
  48 |     var symbolFor = Symbol.for;
  49 |     REACT_ELEMENT_TYPE = symbolFor("react.element");
  50 |     REACT_PORTAL_TYPE = symbolFor("react.portal");
  51 |     exports.Fragment = symbolFor("react.fragment");
  52 |     exports.StrictMode = symbolFor("react.strict_mode");
  53 |     exports.Profiler = symbolFor("react.profiler");
  54 |     REACT_PROVIDER_TYPE = symbolFor("react.provider");
  55 |     REACT_CONTEXT_TYPE = symbolFor("react.context");
  56 |     REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
  57 |     exports.Suspense = symbolFor("react.suspense");
  58 |     REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
  59 |     REACT_MEMO_TYPE = symbolFor("react.memo");
  60 |     REACT_LAZY_TYPE = symbolFor("react.lazy");
  61 |     REACT_BLOCK_TYPE = symbolFor("react.block");
  62 |     REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
  63 |     REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
  64 |     REACT_SCOPE_TYPE = symbolFor("react.scope");
  65 |     REACT_OPAQUE_ID_TYPE = symbolFor("react.opaque.id");
  66 |     REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
  67 |     REACT_OFFSCREEN_TYPE = symbolFor("react.offscreen");
  68 |     REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
  69 |   }
  70 | 
  71 |   var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
  72 |   var FAUX_ITERATOR_SYMBOL = "@@iterator";
  73 |   function getIteratorFn(maybeIterable) {
  74 |     if (maybeIterable === null || typeof maybeIterable !== "object") {
  75 |       return null;
  76 |     }
  77 | 
  78 |     var maybeIterator =
  79 |       (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
  80 |       maybeIterable[FAUX_ITERATOR_SYMBOL];
  81 | 
  82 |     if (typeof maybeIterator === "function") {
  83 |       return maybeIterator;
  84 |     }
  85 | 
  86 |     return null;
  87 |   }
  88 | 
  89 |   var hasOwnProperty = Object.prototype.hasOwnProperty;
  90 | 
  91 |   var _assign = function (to, from) {
  92 |     for (var key in from) {
  93 |       if (hasOwnProperty.call(from, key)) {
  94 |         to[key] = from[key];
  95 |       }
  96 |     }
  97 |   };
  98 | 
  99 |   var assign =
 100 |     Object.assign ||
 101 |     function (target, sources) {
 102 |       if (target == null) {
 103 |         throw new TypeError("Object.assign target cannot be null or undefined");
 104 |       }
 105 | 
 106 |       var to = Object(target);
 107 | 
 108 |       for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {
 109 |         var nextSource = arguments[nextIndex];
 110 | 
 111 |         if (nextSource != null) {
 112 |           _assign(to, Object(nextSource));
 113 |         }
 114 |       }
 115 | 
 116 |       return to;
 117 |     };
 118 | 
 119 |   /**
 120 |    * Keeps track of the current dispatcher.
 121 |    */
 122 |   var ReactCurrentDispatcher = {
 123 |     /**
 124 |      * @internal
 125 |      * @type {ReactComponent}
 126 |      */
 127 |     current: null,
 128 |   };
 129 | 
 130 |   /**
 131 |    * Keeps track of the current batch's configuration such as how long an update
 132 |    * should suspend for if it needs to.
 133 |    */
 134 |   var ReactCurrentBatchConfig = {
 135 |     transition: 0,
 136 |   };
 137 | 
 138 |   /**
 139 |    * Keeps track of the current owner.
 140 |    *
 141 |    * The current owner is the component who should own any components that are
 142 |    * currently being constructed.
 143 |    */
 144 |   var ReactCurrentOwner = {
 145 |     /**
 146 |      * @internal
 147 |      * @type {ReactComponent}
 148 |      */
 149 |     current: null,
 150 |   };
 151 | 
 152 |   var ReactDebugCurrentFrame = {};
 153 |   var currentExtraStackFrame = null;
 154 |   function setExtraStackFrame(stack) {
 155 |     {
 156 |       currentExtraStackFrame = stack;
 157 |     }
 158 |   }
 159 | 
 160 |   {
 161 |     ReactDebugCurrentFrame.setExtraStackFrame = function (stack) {
 162 |       {
 163 |         currentExtraStackFrame = stack;
 164 |       }
 165 |     }; // Stack implementation injected by the current renderer.
 166 | 
 167 |     ReactDebugCurrentFrame.getCurrentStack = null;
 168 | 
 169 |     ReactDebugCurrentFrame.getStackAddendum = function () {
 170 |       var stack = ""; // Add an extra top frame while an element is being validated
 171 | 
 172 |       if (currentExtraStackFrame) {
 173 |         stack += currentExtraStackFrame;
 174 |       } // Delegate to the injected renderer-specific implementation
 175 | 
 176 |       var impl = ReactDebugCurrentFrame.getCurrentStack;
 177 | 
 178 |       if (impl) {
 179 |         stack += impl() || "";
 180 |       }
 181 | 
 182 |       return stack;
 183 |     };
 184 |   }
 185 | 
 186 |   /**
 187 |    * Used by act() to track whether you're inside an act() scope.
 188 |    */
 189 |   var IsSomeRendererActing = {
 190 |     current: false,
 191 |   };
 192 | 
 193 |   var ReactSharedInternals = {
 194 |     ReactCurrentDispatcher: ReactCurrentDispatcher,
 195 |     ReactCurrentBatchConfig: ReactCurrentBatchConfig,
 196 |     ReactCurrentOwner: ReactCurrentOwner,
 197 |     IsSomeRendererActing: IsSomeRendererActing,
 198 |     // Used by renderers to avoid bundling object-assign twice in UMD bundles:
 199 |     assign: assign,
 200 |   };
 201 | 
 202 |   {
 203 |     ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
 204 |   }
 205 | 
 206 |   // by calls to these methods by a Babel plugin.
 207 |   //
 208 |   // In PROD (or in packages without access to React internals),
 209 |   // they are left as they are instead.
 210 | 
 211 |   function warn(format) {
 212 |     {
 213 |       for (
 214 |         var _len = arguments.length,
 215 |           args = new Array(_len > 1 ? _len - 1 : 0),
 216 |           _key = 1;
 217 |         _key < _len;
 218 |         _key++
 219 |       ) {
 220 |         args[_key - 1] = arguments[_key];
 221 |       }
 222 | 
 223 |       printWarning("warn", format, args);
 224 |     }
 225 |   }
 226 |   function error(format) {
 227 |     {
 228 |       for (
 229 |         var _len2 = arguments.length,
 230 |           args = new Array(_len2 > 1 ? _len2 - 1 : 0),
 231 |           _key2 = 1;
 232 |         _key2 < _len2;
 233 |         _key2++
 234 |       ) {
 235 |         args[_key2 - 1] = arguments[_key2];
 236 |       }
 237 | 
 238 |       printWarning("error", format, args);
 239 |     }
 240 |   }
 241 | 
 242 |   function printWarning(level, format, args) {
 243 |     // When changing this logic, you might want to also
 244 |     // update consoleWithStackDev.www.js as well.
 245 |     {
 246 |       var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
 247 |       var stack = ReactDebugCurrentFrame.getStackAddendum();
 248 | 
 249 |       if (stack !== "") {
 250 |         format += "%s";
 251 |         args = args.concat([stack]);
 252 |       }
 253 | 
 254 |       var argsWithFormat = args.map(function (item) {
 255 |         return "" + item;
 256 |       }); // Careful: RN currently depends on this prefix
 257 | 
 258 |       argsWithFormat.unshift("Warning: " + format); // We intentionally don't use spread (or .apply) directly because it
 259 |       // breaks IE9: https://github.com/facebook/react/issues/13610
 260 |       // eslint-disable-next-line react-internal/no-production-logging
 261 | 
 262 |       Function.prototype.apply.call(console[level], console, argsWithFormat);
 263 |     }
 264 |   }
 265 | 
 266 |   var didWarnStateUpdateForUnmountedComponent = {};
 267 | 
 268 |   function warnNoop(publicInstance, callerName) {
 269 |     {
 270 |       var _constructor = publicInstance.constructor;
 271 |       var componentName =
 272 |         (_constructor && (_constructor.displayName || _constructor.name)) ||
 273 |         "ReactClass";
 274 |       var warningKey = componentName + "." + callerName;
 275 | 
 276 |       if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
 277 |         return;
 278 |       }
 279 | 
 280 |       error(
 281 |         "Can't call %s on a component that is not yet mounted. " +
 282 |           "This is a no-op, but it might indicate a bug in your application. " +
 283 |           "Instead, assign to `this.state` directly or define a `state = {};` " +
 284 |           "class property with the desired state in the %s component.",
 285 |         callerName,
 286 |         componentName
 287 |       );
 288 | 
 289 |       didWarnStateUpdateForUnmountedComponent[warningKey] = true;
 290 |     }
 291 |   }
 292 |   /**
 293 |    * This is the abstract API for an update queue.
 294 |    */
 295 | 
 296 |   var ReactNoopUpdateQueue = {
 297 |     /**
 298 |      * Checks whether or not this composite component is mounted.
 299 |      * @param {ReactClass} publicInstance The instance we want to test.
 300 |      * @return {boolean} True if mounted, false otherwise.
 301 |      * @protected
 302 |      * @final
 303 |      */
 304 |     isMounted: function (publicInstance) {
 305 |       return false;
 306 |     },
 307 | 
 308 |     /**
 309 |      * Forces an update. This should only be invoked when it is known with
 310 |      * certainty that we are **not** in a DOM transaction.
 311 |      *
 312 |      * You may want to call this when you know that some deeper aspect of the
 313 |      * component's state has changed but `setState` was not called.
 314 |      *
 315 |      * This will not invoke `shouldComponentUpdate`, but it will invoke
 316 |      * `componentWillUpdate` and `componentDidUpdate`.
 317 |      *
 318 |      * @param {ReactClass} publicInstance The instance that should rerender.
 319 |      * @param {?function} callback Called after component is updated.
 320 |      * @param {?string} callerName name of the calling function in the public API.
 321 |      * @internal
 322 |      */
 323 |     enqueueForceUpdate: function (publicInstance, callback, callerName) {
 324 |       warnNoop(publicInstance, "forceUpdate");
 325 |     },
 326 | 
 327 |     /**
 328 |      * Replaces all of the state. Always use this or `setState` to mutate state.
 329 |      * You should treat `this.state` as immutable.
 330 |      *
 331 |      * There is no guarantee that `this.state` will be immediately updated, so
 332 |      * accessing `this.state` after calling this method may return the old value.
 333 |      *
 334 |      * @param {ReactClass} publicInstance The instance that should rerender.
 335 |      * @param {object} completeState Next state.
 336 |      * @param {?function} callback Called after component is updated.
 337 |      * @param {?string} callerName name of the calling function in the public API.
 338 |      * @internal
 339 |      */
 340 |     enqueueReplaceState: function (
 341 |       publicInstance,
 342 |       completeState,
 343 |       callback,
 344 |       callerName
 345 |     ) {
 346 |       warnNoop(publicInstance, "replaceState");
 347 |     },
 348 | 
 349 |     /**
 350 |      * Sets a subset of the state. This only exists because _pendingState is
 351 |      * internal. This provides a merging strategy that is not available to deep
 352 |      * properties which is confusing. TODO: Expose pendingState or don't use it
 353 |      * during the merge.
 354 |      *
 355 |      * @param {ReactClass} publicInstance The instance that should rerender.
 356 |      * @param {object} partialState Next partial state to be merged with state.
 357 |      * @param {?function} callback Called after component is updated.
 358 |      * @param {?string} Name of the calling function in the public API.
 359 |      * @internal
 360 |      */
 361 |     enqueueSetState: function (
 362 |       publicInstance,
 363 |       partialState,
 364 |       callback,
 365 |       callerName
 366 |     ) {
 367 |       warnNoop(publicInstance, "setState");
 368 |     },
 369 |   };
 370 | 
 371 |   var emptyObject = {};
 372 | 
 373 |   {
 374 |     Object.freeze(emptyObject);
 375 |   }
 376 |   /**
 377 |    * Base class helpers for the updating state of a component.
 378 |    */
 379 | 
 380 |   function Component(props, context, updater) {
 381 |     this.props = props;
 382 |     this.context = context; // If a component has string refs, we will assign a different object later.
 383 | 
 384 |     this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
 385 |     // renderer.
 386 | 
 387 |     this.updater = updater || ReactNoopUpdateQueue;
 388 |   }
 389 | 
 390 |   Component.prototype.isReactComponent = {};
 391 |   /**
 392 |    * Sets a subset of the state. Always use this to mutate
 393 |    * state. You should treat `this.state` as immutable.
 394 |    *
 395 |    * There is no guarantee that `this.state` will be immediately updated, so
 396 |    * accessing `this.state` after calling this method may return the old value.
 397 |    *
 398 |    * There is no guarantee that calls to `setState` will run synchronously,
 399 |    * as they may eventually be batched together.  You can provide an optional
 400 |    * callback that will be executed when the call to setState is actually
 401 |    * completed.
 402 |    *
 403 |    * When a function is provided to setState, it will be called at some point in
 404 |    * the future (not synchronously). It will be called with the up to date
 405 |    * component arguments (state, props, context). These values can be different
 406 |    * from this.* because your function may be called after receiveProps but before
 407 |    * shouldComponentUpdate, and this new state, props, and context will not yet be
 408 |    * assigned to this.
 409 |    *
 410 |    * @param {object|function} partialState Next partial state or function to
 411 |    *        produce next partial state to be merged with current state.
 412 |    * @param {?function} callback Called after state is updated.
 413 |    * @final
 414 |    * @protected
 415 |    */
 416 | 
 417 |   Component.prototype.setState = function (partialState, callback) {
 418 |     if (
 419 |       !(
 420 |         typeof partialState === "object" ||
 421 |         typeof partialState === "function" ||
 422 |         partialState == null
 423 |       )
 424 |     ) {
 425 |       {
 426 |         throw Error(
 427 |           "setState(...): takes an object of state variables to update or a function which returns an object of state variables."
 428 |         );
 429 |       }
 430 |     }
 431 | 
 432 |     this.updater.enqueueSetState(this, partialState, callback, "setState");
 433 |   };
 434 |   /**
 435 |    * Forces an update. This should only be invoked when it is known with
 436 |    * certainty that we are **not** in a DOM transaction.
 437 |    *
 438 |    * You may want to call this when you know that some deeper aspect of the
 439 |    * component's state has changed but `setState` was not called.
 440 |    *
 441 |    * This will not invoke `shouldComponentUpdate`, but it will invoke
 442 |    * `componentWillUpdate` and `componentDidUpdate`.
 443 |    *
 444 |    * @param {?function} callback Called after update is complete.
 445 |    * @final
 446 |    * @protected
 447 |    */
 448 | 
 449 |   Component.prototype.forceUpdate = function (callback) {
 450 |     this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
 451 |   };
 452 |   /**
 453 |    * Deprecated APIs. These APIs used to exist on classic React classes but since
 454 |    * we would like to deprecate them, we're not going to move them over to this
 455 |    * modern base class. Instead, we define a getter that warns if it's accessed.
 456 |    */
 457 | 
 458 |   {
 459 |     var deprecatedAPIs = {
 460 |       isMounted: [
 461 |         "isMounted",
 462 |         "Instead, make sure to clean up subscriptions and pending requests in " +
 463 |           "componentWillUnmount to prevent memory leaks.",
 464 |       ],
 465 |       replaceState: [
 466 |         "replaceState",
 467 |         "Refactor your code to use setState instead (see " +
 468 |           "https://github.com/facebook/react/issues/3236).",
 469 |       ],
 470 |     };
 471 | 
 472 |     var defineDeprecationWarning = function (methodName, info) {
 473 |       Object.defineProperty(Component.prototype, methodName, {
 474 |         get: function () {
 475 |           warn(
 476 |             "%s(...) is deprecated in plain JavaScript React classes. %s",
 477 |             info[0],
 478 |             info[1]
 479 |           );
 480 | 
 481 |           return undefined;
 482 |         },
 483 |       });
 484 |     };
 485 | 
 486 |     for (var fnName in deprecatedAPIs) {
 487 |       if (deprecatedAPIs.hasOwnProperty(fnName)) {
 488 |         defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
 489 |       }
 490 |     }
 491 |   }
 492 | 
 493 |   function ComponentDummy() {}
 494 | 
 495 |   ComponentDummy.prototype = Component.prototype;
 496 |   /**
 497 |    * Convenience component with default shallow equality check for sCU.
 498 |    */
 499 | 
 500 |   function PureComponent(props, context, updater) {
 501 |     this.props = props;
 502 |     this.context = context; // If a component has string refs, we will assign a different object later.
 503 | 
 504 |     this.refs = emptyObject;
 505 |     this.updater = updater || ReactNoopUpdateQueue;
 506 |   }
 507 | 
 508 |   var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
 509 |   pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
 510 | 
 511 |   assign(pureComponentPrototype, Component.prototype);
 512 | 
 513 |   pureComponentPrototype.isPureReactComponent = true;
 514 | 
 515 |   // an immutable object with a single mutable value
 516 |   function createRef() {
 517 |     var refObject = {
 518 |       current: null,
 519 |     };
 520 | 
 521 |     {
 522 |       Object.seal(refObject);
 523 |     }
 524 | 
 525 |     return refObject;
 526 |   }
 527 | 
 528 |   function getWrappedName(outerType, innerType, wrapperName) {
 529 |     var functionName = innerType.displayName || innerType.name || "";
 530 |     return (
 531 |       outerType.displayName ||
 532 |       (functionName !== ""
 533 |         ? wrapperName + "(" + functionName + ")"
 534 |         : wrapperName)
 535 |     );
 536 |   }
 537 | 
 538 |   function getContextName(type) {
 539 |     return type.displayName || "Context";
 540 |   }
 541 | 
 542 |   function getComponentName(type) {
 543 |     if (type == null) {
 544 |       // Host root, text node or just invalid type.
 545 |       return null;
 546 |     }
 547 | 
 548 |     {
 549 |       if (typeof type.tag === "number") {
 550 |         error(
 551 |           "Received an unexpected object in getComponentName(). " +
 552 |             "This is likely a bug in React. Please file an issue."
 553 |         );
 554 |       }
 555 |     }
 556 | 
 557 |     if (typeof type === "function") {
 558 |       return type.displayName || type.name || null;
 559 |     }
 560 | 
 561 |     if (typeof type === "string") {
 562 |       return type;
 563 |     }
 564 | 
 565 |     switch (type) {
 566 |       case exports.Fragment:
 567 |         return "Fragment";
 568 | 
 569 |       case REACT_PORTAL_TYPE:
 570 |         return "Portal";
 571 | 
 572 |       case exports.Profiler:
 573 |         return "Profiler";
 574 | 
 575 |       case exports.StrictMode:
 576 |         return "StrictMode";
 577 | 
 578 |       case exports.Suspense:
 579 |         return "Suspense";
 580 | 
 581 |       case REACT_SUSPENSE_LIST_TYPE:
 582 |         return "SuspenseList";
 583 |     }
 584 | 
 585 |     if (typeof type === "object") {
 586 |       switch (type.$$typeof) {
 587 |         case REACT_CONTEXT_TYPE:
 588 |           var context = type;
 589 |           return getContextName(context) + ".Consumer";
 590 | 
 591 |         case REACT_PROVIDER_TYPE:
 592 |           var provider = type;
 593 |           return getContextName(provider._context) + ".Provider";
 594 | 
 595 |         case REACT_FORWARD_REF_TYPE:
 596 |           return getWrappedName(type, type.render, "ForwardRef");
 597 | 
 598 |         case REACT_MEMO_TYPE:
 599 |           return getComponentName(type.type);
 600 | 
 601 |         case REACT_BLOCK_TYPE:
 602 |           return getComponentName(type._render);
 603 | 
 604 |         case REACT_LAZY_TYPE: {
 605 |           var lazyComponent = type;
 606 |           var payload = lazyComponent._payload;
 607 |           var init = lazyComponent._init;
 608 | 
 609 |           try {
 610 |             return getComponentName(init(payload));
 611 |           } catch (x) {
 612 |             return null;
 613 |           }
 614 |         }
 615 |       }
 616 |     }
 617 | 
 618 |     return null;
 619 |   }
 620 | 
 621 |   var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 622 |   var RESERVED_PROPS = {
 623 |     key: true,
 624 |     ref: true,
 625 |     __self: true,
 626 |     __source: true,
 627 |   };
 628 |   var specialPropKeyWarningShown,
 629 |     specialPropRefWarningShown,
 630 |     didWarnAboutStringRefs;
 631 | 
 632 |   {
 633 |     didWarnAboutStringRefs = {};
 634 |   }
 635 | 
 636 |   function hasValidRef(config) {
 637 |     {
 638 |       if (hasOwnProperty$1.call(config, "ref")) {
 639 |         var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
 640 | 
 641 |         if (getter && getter.isReactWarning) {
 642 |           return false;
 643 |         }
 644 |       }
 645 |     }
 646 | 
 647 |     return config.ref !== undefined;
 648 |   }
 649 | 
 650 |   function hasValidKey(config) {
 651 |     {
 652 |       if (hasOwnProperty$1.call(config, "key")) {
 653 |         var getter = Object.getOwnPropertyDescriptor(config, "key").get;
 654 | 
 655 |         if (getter && getter.isReactWarning) {
 656 |           return false;
 657 |         }
 658 |       }
 659 |     }
 660 | 
 661 |     return config.key !== undefined;
 662 |   }
 663 | 
 664 |   function defineKeyPropWarningGetter(props, displayName) {
 665 |     var warnAboutAccessingKey = function () {
 666 |       {
 667 |         if (!specialPropKeyWarningShown) {
 668 |           specialPropKeyWarningShown = true;
 669 | 
 670 |           error(
 671 |             "%s: `key` is not a prop. Trying to access it will result " +
 672 |               "in `undefined` being returned. If you need to access the same " +
 673 |               "value within the child component, you should pass it as a different " +
 674 |               "prop. (https://reactjs.org/link/special-props)",
 675 |             displayName
 676 |           );
 677 |         }
 678 |       }
 679 |     };
 680 | 
 681 |     warnAboutAccessingKey.isReactWarning = true;
 682 |     Object.defineProperty(props, "key", {
 683 |       get: warnAboutAccessingKey,
 684 |       configurable: true,
 685 |     });
 686 |   }
 687 | 
 688 |   function defineRefPropWarningGetter(props, displayName) {
 689 |     var warnAboutAccessingRef = function () {
 690 |       {
 691 |         if (!specialPropRefWarningShown) {
 692 |           specialPropRefWarningShown = true;
 693 | 
 694 |           error(
 695 |             "%s: `ref` is not a prop. Trying to access it will result " +
 696 |               "in `undefined` being returned. If you need to access the same " +
 697 |               "value within the child component, you should pass it as a different " +
 698 |               "prop. (https://reactjs.org/link/special-props)",
 699 |             displayName
 700 |           );
 701 |         }
 702 |       }
 703 |     };
 704 | 
 705 |     warnAboutAccessingRef.isReactWarning = true;
 706 |     Object.defineProperty(props, "ref", {
 707 |       get: warnAboutAccessingRef,
 708 |       configurable: true,
 709 |     });
 710 |   }
 711 | 
 712 |   function warnIfStringRefCannotBeAutoConverted(config) {
 713 |     {
 714 |       if (
 715 |         typeof config.ref === "string" &&
 716 |         ReactCurrentOwner.current &&
 717 |         config.__self &&
 718 |         ReactCurrentOwner.current.stateNode !== config.__self
 719 |       ) {
 720 |         var componentName = getComponentName(ReactCurrentOwner.current.type);
 721 | 
 722 |         if (!didWarnAboutStringRefs[componentName]) {
 723 |           error(
 724 |             'Component "%s" contains the string ref "%s". ' +
 725 |               "Support for string refs will be removed in a future major release. " +
 726 |               "This case cannot be automatically converted to an arrow function. " +
 727 |               "We ask you to manually fix this case by using useRef() or createRef() instead. " +
 728 |               "Learn more about using refs safely here: " +
 729 |               "https://reactjs.org/link/strict-mode-string-ref",
 730 |             componentName,
 731 |             config.ref
 732 |           );
 733 | 
 734 |           didWarnAboutStringRefs[componentName] = true;
 735 |         }
 736 |       }
 737 |     }
 738 |   }
 739 |   /**
 740 |    * Factory method to create a new React element. This no longer adheres to
 741 |    * the class pattern, so do not use new to call it. Also, instanceof check
 742 |    * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
 743 |    * if something is a React Element.
 744 |    *
 745 |    * @param {*} type
 746 |    * @param {*} props
 747 |    * @param {*} key
 748 |    * @param {string|object} ref
 749 |    * @param {*} owner
 750 |    * @param {*} self A *temporary* helper to detect places where `this` is
 751 |    * different from the `owner` when React.createElement is called, so that we
 752 |    * can warn. We want to get rid of owner and replace string `ref`s with arrow
 753 |    * functions, and as long as `this` and owner are the same, there will be no
 754 |    * change in behavior.
 755 |    * @param {*} source An annotation object (added by a transpiler or otherwise)
 756 |    * indicating filename, line number, and/or other information.
 757 |    * @internal
 758 |    */
 759 | 
 760 |   var ReactElement = function (type, key, ref, self, source, owner, props) {
 761 |     var element = {
 762 |       // This tag allows us to uniquely identify this as a React Element
 763 |       $$typeof: REACT_ELEMENT_TYPE,
 764 |       // Built-in properties that belong on the element
 765 |       type: type,
 766 |       key: key,
 767 |       ref: ref,
 768 |       props: props,
 769 |       // Record the component responsible for creating this element.
 770 |       _owner: owner,
 771 |     };
 772 | 
 773 |     {
 774 |       // The validation flag is currently mutative. We put it on
 775 |       // an external backing store so that we can freeze the whole object.
 776 |       // This can be replaced with a WeakMap once they are implemented in
 777 |       // commonly used development environments.
 778 |       element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
 779 |       // the validation flag non-enumerable (where possible, which should
 780 |       // include every environment we run tests in), so the test framework
 781 |       // ignores it.
 782 | 
 783 |       Object.defineProperty(element._store, "validated", {
 784 |         configurable: false,
 785 |         enumerable: false,
 786 |         writable: true,
 787 |         value: false,
 788 |       }); // self and source are DEV only properties.
 789 | 
 790 |       Object.defineProperty(element, "_self", {
 791 |         configurable: false,
 792 |         enumerable: false,
 793 |         writable: false,
 794 |         value: self,
 795 |       }); // Two elements created in two different places should be considered
 796 |       // equal for testing purposes and therefore we hide it from enumeration.
 797 | 
 798 |       Object.defineProperty(element, "_source", {
 799 |         configurable: false,
 800 |         enumerable: false,
 801 |         writable: false,
 802 |         value: source,
 803 |       });
 804 | 
 805 |       if (Object.freeze) {
 806 |         Object.freeze(element.props);
 807 |         Object.freeze(element);
 808 |       }
 809 |     }
 810 | 
 811 |     return element;
 812 |   };
 813 |   /**
 814 |    * Create and return a new ReactElement of the given type.
 815 |    * See https://reactjs.org/docs/react-api.html#createelement
 816 |    */
 817 | 
 818 |   function createElement(type, config, children) {
 819 |     var propName; // Reserved names are extracted
 820 | 
 821 |     var props = {};
 822 |     var key = null;
 823 |     var ref = null;
 824 |     var self = null;
 825 |     var source = null;
 826 | 
 827 |     if (config != null) {
 828 |       if (hasValidRef(config)) {
 829 |         ref = config.ref;
 830 | 
 831 |         {
 832 |           warnIfStringRefCannotBeAutoConverted(config);
 833 |         }
 834 |       }
 835 | 
 836 |       if (hasValidKey(config)) {
 837 |         key = "" + config.key;
 838 |       }
 839 | 
 840 |       self = config.__self === undefined ? null : config.__self;
 841 |       source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
 842 | 
 843 |       for (propName in config) {
 844 |         if (
 845 |           hasOwnProperty$1.call(config, propName) &&
 846 |           !RESERVED_PROPS.hasOwnProperty(propName)
 847 |         ) {
 848 |           props[propName] = config[propName];
 849 |         }
 850 |       }
 851 |     } // Children can be more than one argument, and those are transferred onto
 852 |     // the newly allocated props object.
 853 | 
 854 |     var childrenLength = arguments.length - 2;
 855 | 
 856 |     if (childrenLength === 1) {
 857 |       props.children = children;
 858 |     } else if (childrenLength > 1) {
 859 |       var childArray = Array(childrenLength);
 860 | 
 861 |       for (var i = 0; i < childrenLength; i++) {
 862 |         childArray[i] = arguments[i + 2];
 863 |       }
 864 | 
 865 |       {
 866 |         if (Object.freeze) {
 867 |           Object.freeze(childArray);
 868 |         }
 869 |       }
 870 | 
 871 |       props.children = childArray;
 872 |     } // Resolve default props
 873 | 
 874 |     if (type && type.defaultProps) {
 875 |       var defaultProps = type.defaultProps;
 876 | 
 877 |       for (propName in defaultProps) {
 878 |         if (props[propName] === undefined) {
 879 |           props[propName] = defaultProps[propName];
 880 |         }
 881 |       }
 882 |     }
 883 | 
 884 |     {
 885 |       if (key || ref) {
 886 |         var displayName =
 887 |           typeof type === "function"
 888 |             ? type.displayName || type.name || "Unknown"
 889 |             : type;
 890 | 
 891 |         if (key) {
 892 |           defineKeyPropWarningGetter(props, displayName);
 893 |         }
 894 | 
 895 |         if (ref) {
 896 |           defineRefPropWarningGetter(props, displayName);
 897 |         }
 898 |       }
 899 |     }
 900 | 
 901 |     return ReactElement(
 902 |       type,
 903 |       key,
 904 |       ref,
 905 |       self,
 906 |       source,
 907 |       ReactCurrentOwner.current,
 908 |       props
 909 |     );
 910 |   }
 911 |   function cloneAndReplaceKey(oldElement, newKey) {
 912 |     var newElement = ReactElement(
 913 |       oldElement.type,
 914 |       newKey,
 915 |       oldElement.ref,
 916 |       oldElement._self,
 917 |       oldElement._source,
 918 |       oldElement._owner,
 919 |       oldElement.props
 920 |     );
 921 |     return newElement;
 922 |   }
 923 |   /**
 924 |    * Clone and return a new ReactElement using element as the starting point.
 925 |    * See https://reactjs.org/docs/react-api.html#cloneelement
 926 |    */
 927 | 
 928 |   function cloneElement(element, config, children) {
 929 |     if (!!(element === null || element === undefined)) {
 930 |       {
 931 |         throw Error(
 932 |           "React.cloneElement(...): The argument must be a React element, but you passed " +
 933 |             element +
 934 |             "."
 935 |         );
 936 |       }
 937 |     }
 938 | 
 939 |     var propName; // Original props are copied
 940 | 
 941 |     var props = assign({}, element.props); // Reserved names are extracted
 942 | 
 943 |     var key = element.key;
 944 |     var ref = element.ref; // Self is preserved since the owner is preserved.
 945 | 
 946 |     var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
 947 |     // transpiler, and the original source is probably a better indicator of the
 948 |     // true owner.
 949 | 
 950 |     var source = element._source; // Owner will be preserved, unless ref is overridden
 951 | 
 952 |     var owner = element._owner;
 953 | 
 954 |     if (config != null) {
 955 |       if (hasValidRef(config)) {
 956 |         // Silently steal the ref from the parent.
 957 |         ref = config.ref;
 958 |         owner = ReactCurrentOwner.current;
 959 |       }
 960 | 
 961 |       if (hasValidKey(config)) {
 962 |         key = "" + config.key;
 963 |       } // Remaining properties override existing props
 964 | 
 965 |       var defaultProps;
 966 | 
 967 |       if (element.type && element.type.defaultProps) {
 968 |         defaultProps = element.type.defaultProps;
 969 |       }
 970 | 
 971 |       for (propName in config) {
 972 |         if (
 973 |           hasOwnProperty$1.call(config, propName) &&
 974 |           !RESERVED_PROPS.hasOwnProperty(propName)
 975 |         ) {
 976 |           if (config[propName] === undefined && defaultProps !== undefined) {
 977 |             // Resolve default props
 978 |             props[propName] = defaultProps[propName];
 979 |           } else {
 980 |             props[propName] = config[propName];
 981 |           }
 982 |         }
 983 |       }
 984 |     } // Children can be more than one argument, and those are transferred onto
 985 |     // the newly allocated props object.
 986 | 
 987 |     var childrenLength = arguments.length - 2;
 988 | 
 989 |     if (childrenLength === 1) {
 990 |       props.children = children;
 991 |     } else if (childrenLength > 1) {
 992 |       var childArray = Array(childrenLength);
 993 | 
 994 |       for (var i = 0; i < childrenLength; i++) {
 995 |         childArray[i] = arguments[i + 2];
 996 |       }
 997 | 
 998 |       props.children = childArray;
 999 |     }
1000 | 
1001 |     return ReactElement(element.type, key, ref, self, source, owner, props);
1002 |   }
1003 |   /**
1004 |    * Verifies the object is a ReactElement.
1005 |    * See https://reactjs.org/docs/react-api.html#isvalidelement
1006 |    * @param {?object} object
1007 |    * @return {boolean} True if `object` is a ReactElement.
1008 |    * @final
1009 |    */
1010 | 
1011 |   function isValidElement(object) {
1012 |     return (
1013 |       typeof object === "object" &&
1014 |       object !== null &&
1015 |       object.$$typeof === REACT_ELEMENT_TYPE
1016 |     );
1017 |   }
1018 | 
1019 |   var SEPARATOR = ".";
1020 |   var SUBSEPARATOR = ":";
1021 |   /**
1022 |    * Escape and wrap key so it is safe to use as a reactid
1023 |    *
1024 |    * @param {string} key to be escaped.
1025 |    * @return {string} the escaped key.
1026 |    */
1027 | 
1028 |   function escape(key) {
1029 |     var escapeRegex = /[=:]/g;
1030 |     var escaperLookup = {
1031 |       "=": "=0",
1032 |       ":": "=2",
1033 |     };
1034 |     var escapedString = key.replace(escapeRegex, function (match) {
1035 |       return escaperLookup[match];
1036 |     });
1037 |     return "$" + escapedString;
1038 |   }
1039 |   /**
1040 |    * TODO: Test that a single child and an array with one item have the same key
1041 |    * pattern.
1042 |    */
1043 | 
1044 |   var didWarnAboutMaps = false;
1045 |   var userProvidedKeyEscapeRegex = /\/+/g;
1046 | 
1047 |   function escapeUserProvidedKey(text) {
1048 |     return text.replace(userProvidedKeyEscapeRegex, "$&/");
1049 |   }
1050 |   /**
1051 |    * Generate a key string that identifies a element within a set.
1052 |    *
1053 |    * @param {*} element A element that could contain a manual key.
1054 |    * @param {number} index Index that is used if a manual key is not provided.
1055 |    * @return {string}
1056 |    */
1057 | 
1058 |   function getElementKey(element, index) {
1059 |     // Do some typechecking here since we call this blindly. We want to ensure
1060 |     // that we don't block potential future ES APIs.
1061 |     if (
1062 |       typeof element === "object" &&
1063 |       element !== null &&
1064 |       element.key != null
1065 |     ) {
1066 |       // Explicit key
1067 |       return escape("" + element.key);
1068 |     } // Implicit key determined by the index in the set
1069 | 
1070 |     return index.toString(36);
1071 |   }
1072 | 
1073 |   function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
1074 |     var type = typeof children;
1075 | 
1076 |     if (type === "undefined" || type === "boolean") {
1077 |       // All of the above are perceived as null.
1078 |       children = null;
1079 |     }
1080 | 
1081 |     var invokeCallback = false;
1082 | 
1083 |     if (children === null) {
1084 |       invokeCallback = true;
1085 |     } else {
1086 |       switch (type) {
1087 |         case "string":
1088 |         case "number":
1089 |           invokeCallback = true;
1090 |           break;
1091 | 
1092 |         case "object":
1093 |           switch (children.$$typeof) {
1094 |             case REACT_ELEMENT_TYPE:
1095 |             case REACT_PORTAL_TYPE:
1096 |               invokeCallback = true;
1097 |           }
1098 |       }
1099 |     }
1100 | 
1101 |     if (invokeCallback) {
1102 |       var _child = children;
1103 |       var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array
1104 |       // so that it's consistent if the number of children grows:
1105 | 
1106 |       var childKey =
1107 |         nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
1108 | 
1109 |       if (Array.isArray(mappedChild)) {
1110 |         var escapedChildKey = "";
1111 | 
1112 |         if (childKey != null) {
1113 |           escapedChildKey = escapeUserProvidedKey(childKey) + "/";
1114 |         }
1115 | 
1116 |         mapIntoArray(mappedChild, array, escapedChildKey, "", function (c) {
1117 |           return c;
1118 |         });
1119 |       } else if (mappedChild != null) {
1120 |         if (isValidElement(mappedChild)) {
1121 |           mappedChild = cloneAndReplaceKey(
1122 |             mappedChild, // Keep both the (mapped) and old keys if they differ, just as
1123 |             // traverseAllChildren used to do for objects as children
1124 |             escapedPrefix + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
1125 |               (mappedChild.key && (!_child || _child.key !== mappedChild.key) // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
1126 |                 ? escapeUserProvidedKey("" + mappedChild.key) + "/"
1127 |                 : "") +
1128 |               childKey
1129 |           );
1130 |         }
1131 | 
1132 |         array.push(mappedChild);
1133 |       }
1134 | 
1135 |       return 1;
1136 |     }
1137 | 
1138 |     var child;
1139 |     var nextName;
1140 |     var subtreeCount = 0; // Count of children found in the current subtree.
1141 | 
1142 |     var nextNamePrefix =
1143 |       nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
1144 | 
1145 |     if (Array.isArray(children)) {
1146 |       for (var i = 0; i < children.length; i++) {
1147 |         child = children[i];
1148 |         nextName = nextNamePrefix + getElementKey(child, i);
1149 |         subtreeCount += mapIntoArray(
1150 |           child,
1151 |           array,
1152 |           escapedPrefix,
1153 |           nextName,
1154 |           callback
1155 |         );
1156 |       }
1157 |     } else {
1158 |       var iteratorFn = getIteratorFn(children);
1159 | 
1160 |       if (typeof iteratorFn === "function") {
1161 |         var iterableChildren = children;
1162 | 
1163 |         {
1164 |           // Warn about using Maps as children
1165 |           if (iteratorFn === iterableChildren.entries) {
1166 |             if (!didWarnAboutMaps) {
1167 |               warn(
1168 |                 "Using Maps as children is not supported. " +
1169 |                   "Use an array of keyed ReactElements instead."
1170 |               );
1171 |             }
1172 | 
1173 |             didWarnAboutMaps = true;
1174 |           }
1175 |         }
1176 | 
1177 |         var iterator = iteratorFn.call(iterableChildren);
1178 |         var step;
1179 |         var ii = 0;
1180 | 
1181 |         while (!(step = iterator.next()).done) {
1182 |           child = step.value;
1183 |           nextName = nextNamePrefix + getElementKey(child, ii++);
1184 |           subtreeCount += mapIntoArray(
1185 |             child,
1186 |             array,
1187 |             escapedPrefix,
1188 |             nextName,
1189 |             callback
1190 |           );
1191 |         }
1192 |       } else if (type === "object") {
1193 |         var childrenString = "" + children;
1194 | 
1195 |         {
1196 |           {
1197 |             throw Error(
1198 |               "Objects are not valid as a React child (found: " +
1199 |                 (childrenString === "[object Object]"
1200 |                   ? "object with keys {" +
1201 |                     Object.keys(children).join(", ") +
1202 |                     "}"
1203 |                   : childrenString) +
1204 |                 "). If you meant to render a collection of children, use an array instead."
1205 |             );
1206 |           }
1207 |         }
1208 |       }
1209 |     }
1210 | 
1211 |     return subtreeCount;
1212 |   }
1213 | 
1214 |   /**
1215 |    * Maps children that are typically specified as `props.children`.
1216 |    *
1217 |    * See https://reactjs.org/docs/react-api.html#reactchildrenmap
1218 |    *
1219 |    * The provided mapFunction(child, index) will be called for each
1220 |    * leaf child.
1221 |    *
1222 |    * @param {?*} children Children tree container.
1223 |    * @param {function(*, int)} func The map function.
1224 |    * @param {*} context Context for mapFunction.
1225 |    * @return {object} Object containing the ordered map of results.
1226 |    */
1227 |   function mapChildren(children, func, context) {
1228 |     if (children == null) {
1229 |       return children;
1230 |     }
1231 | 
1232 |     var result = [];
1233 |     var count = 0;
1234 |     mapIntoArray(children, result, "", "", function (child) {
1235 |       return func.call(context, child, count++);
1236 |     });
1237 |     return result;
1238 |   }
1239 |   /**
1240 |    * Count the number of children that are typically specified as
1241 |    * `props.children`.
1242 |    *
1243 |    * See https://reactjs.org/docs/react-api.html#reactchildrencount
1244 |    *
1245 |    * @param {?*} children Children tree container.
1246 |    * @return {number} The number of children.
1247 |    */
1248 | 
1249 |   function countChildren(children) {
1250 |     var n = 0;
1251 |     mapChildren(children, function () {
1252 |       n++; // Don't return anything
1253 |     });
1254 |     return n;
1255 |   }
1256 | 
1257 |   /**
1258 |    * Iterates through children that are typically specified as `props.children`.
1259 |    *
1260 |    * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
1261 |    *
1262 |    * The provided forEachFunc(child, index) will be called for each
1263 |    * leaf child.
1264 |    *
1265 |    * @param {?*} children Children tree container.
1266 |    * @param {function(*, int)} forEachFunc
1267 |    * @param {*} forEachContext Context for forEachContext.
1268 |    */
1269 |   function forEachChildren(children, forEachFunc, forEachContext) {
1270 |     mapChildren(
1271 |       children,
1272 |       function () {
1273 |         forEachFunc.apply(this, arguments); // Don't return anything.
1274 |       },
1275 |       forEachContext
1276 |     );
1277 |   }
1278 |   /**
1279 |    * Flatten a children object (typically specified as `props.children`) and
1280 |    * return an array with appropriately re-keyed children.
1281 |    *
1282 |    * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
1283 |    */
1284 | 
1285 |   function toArray(children) {
1286 |     return (
1287 |       mapChildren(children, function (child) {
1288 |         return child;
1289 |       }) || []
1290 |     );
1291 |   }
1292 |   /**
1293 |    * Returns the first child in a collection of children and verifies that there
1294 |    * is only one child in the collection.
1295 |    *
1296 |    * See https://reactjs.org/docs/react-api.html#reactchildrenonly
1297 |    *
1298 |    * The current implementation of this function assumes that a single child gets
1299 |    * passed without a wrapper, but the purpose of this helper function is to
1300 |    * abstract away the particular structure of children.
1301 |    *
1302 |    * @param {?object} children Child collection structure.
1303 |    * @return {ReactElement} The first and only `ReactElement` contained in the
1304 |    * structure.
1305 |    */
1306 | 
1307 |   function onlyChild(children) {
1308 |     if (!isValidElement(children)) {
1309 |       {
1310 |         throw Error(
1311 |           "React.Children.only expected to receive a single React element child."
1312 |         );
1313 |       }
1314 |     }
1315 | 
1316 |     return children;
1317 |   }
1318 | 
1319 |   function createContext(defaultValue, calculateChangedBits) {
1320 |     if (calculateChangedBits === undefined) {
1321 |       calculateChangedBits = null;
1322 |     } else {
1323 |       {
1324 |         if (
1325 |           calculateChangedBits !== null &&
1326 |           typeof calculateChangedBits !== "function"
1327 |         ) {
1328 |           error(
1329 |             "createContext: Expected the optional second argument to be a " +
1330 |               "function. Instead received: %s",
1331 |             calculateChangedBits
1332 |           );
1333 |         }
1334 |       }
1335 |     }
1336 | 
1337 |     var context = {
1338 |       $$typeof: REACT_CONTEXT_TYPE,
1339 |       _calculateChangedBits: calculateChangedBits,
1340 |       // As a workaround to support multiple concurrent renderers, we categorize
1341 |       // some renderers as primary and others as secondary. We only expect
1342 |       // there to be two concurrent renderers at most: React Native (primary) and
1343 |       // Fabric (secondary); React DOM (primary) and React ART (secondary).
1344 |       // Secondary renderers store their context values on separate fields.
1345 |       _currentValue: defaultValue,
1346 |       _currentValue2: defaultValue,
1347 |       // Used to track how many concurrent renderers this context currently
1348 |       // supports within in a single renderer. Such as parallel server rendering.
1349 |       _threadCount: 0,
1350 |       // These are circular
1351 |       Provider: null,
1352 |       Consumer: null,
1353 |     };
1354 |     context.Provider = {
1355 |       $$typeof: REACT_PROVIDER_TYPE,
1356 |       _context: context,
1357 |     };
1358 |     var hasWarnedAboutUsingNestedContextConsumers = false;
1359 |     var hasWarnedAboutUsingConsumerProvider = false;
1360 |     var hasWarnedAboutDisplayNameOnConsumer = false;
1361 | 
1362 |     {
1363 |       // A separate object, but proxies back to the original context object for
1364 |       // backwards compatibility. It has a different $$typeof, so we can properly
1365 |       // warn for the incorrect usage of Context as a Consumer.
1366 |       var Consumer = {
1367 |         $$typeof: REACT_CONTEXT_TYPE,
1368 |         _context: context,
1369 |         _calculateChangedBits: context._calculateChangedBits,
1370 |       }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
1371 | 
1372 |       Object.defineProperties(Consumer, {
1373 |         Provider: {
1374 |           get: function () {
1375 |             if (!hasWarnedAboutUsingConsumerProvider) {
1376 |               hasWarnedAboutUsingConsumerProvider = true;
1377 | 
1378 |               error(
1379 |                 "Rendering <Context.Consumer.Provider> is not supported and will be removed in " +
1380 |                   "a future major release. Did you mean to render <Context.Provider> instead?"
1381 |               );
1382 |             }
1383 | 
1384 |             return context.Provider;
1385 |           },
1386 |           set: function (_Provider) {
1387 |             context.Provider = _Provider;
1388 |           },
1389 |         },
1390 |         _currentValue: {
1391 |           get: function () {
1392 |             return context._currentValue;
1393 |           },
1394 |           set: function (_currentValue) {
1395 |             context._currentValue = _currentValue;
1396 |           },
1397 |         },
1398 |         _currentValue2: {
1399 |           get: function () {
1400 |             return context._currentValue2;
1401 |           },
1402 |           set: function (_currentValue2) {
1403 |             context._currentValue2 = _currentValue2;
1404 |           },
1405 |         },
1406 |         _threadCount: {
1407 |           get: function () {
1408 |             return context._threadCount;
1409 |           },
1410 |           set: function (_threadCount) {
1411 |             context._threadCount = _threadCount;
1412 |           },
1413 |         },
1414 |         Consumer: {
1415 |           get: function () {
1416 |             if (!hasWarnedAboutUsingNestedContextConsumers) {
1417 |               hasWarnedAboutUsingNestedContextConsumers = true;
1418 | 
1419 |               error(
1420 |                 "Rendering <Context.Consumer.Consumer> is not supported and will be removed in " +
1421 |                   "a future major release. Did you mean to render <Context.Consumer> instead?"
1422 |               );
1423 |             }
1424 | 
1425 |             return context.Consumer;
1426 |           },
1427 |         },
1428 |         displayName: {
1429 |           get: function () {
1430 |             return context.displayName;
1431 |           },
1432 |           set: function (displayName) {
1433 |             if (!hasWarnedAboutDisplayNameOnConsumer) {
1434 |               warn(
1435 |                 "Setting `displayName` on Context.Consumer has no effect. " +
1436 |                   "You should set it directly on the context with Context.displayName = '%s'.",
1437 |                 displayName
1438 |               );
1439 | 
1440 |               hasWarnedAboutDisplayNameOnConsumer = true;
1441 |             }
1442 |           },
1443 |         },
1444 |       }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
1445 | 
1446 |       context.Consumer = Consumer;
1447 |     }
1448 | 
1449 |     {
1450 |       context._currentRenderer = null;
1451 |       context._currentRenderer2 = null;
1452 |     }
1453 | 
1454 |     return context;
1455 |   }
1456 | 
1457 |   var Uninitialized = -1;
1458 |   var Pending = 0;
1459 |   var Resolved = 1;
1460 |   var Rejected = 2;
1461 | 
1462 |   function lazyInitializer(payload) {
1463 |     if (payload._status === Uninitialized) {
1464 |       var ctor = payload._result;
1465 |       var thenable = ctor(); // Transition to the next state.
1466 | 
1467 |       var pending = payload;
1468 |       pending._status = Pending;
1469 |       pending._result = thenable;
1470 |       thenable.then(
1471 |         function (moduleObject) {
1472 |           if (payload._status === Pending) {
1473 |             var defaultExport = moduleObject.default;
1474 | 
1475 |             {
1476 |               if (defaultExport === undefined) {
1477 |                 error(
1478 |                   "lazy: Expected the result of a dynamic import() call. " +
1479 |                     "Instead received: %s\n\nYour code should look like: \n  " + // Break up imports to avoid accidentally parsing them as dependencies.
1480 |                     "const MyComponent = lazy(() => imp" +
1481 |                     "ort('./MyComponent'))",
1482 |                   moduleObject
1483 |                 );
1484 |               }
1485 |             } // Transition to the next state.
1486 | 
1487 |             var resolved = payload;
1488 |             resolved._status = Resolved;
1489 |             resolved._result = defaultExport;
1490 |           }
1491 |         },
1492 |         function (error) {
1493 |           if (payload._status === Pending) {
1494 |             // Transition to the next state.
1495 |             var rejected = payload;
1496 |             rejected._status = Rejected;
1497 |             rejected._result = error;
1498 |           }
1499 |         }
1500 |       );
1501 |     }
1502 | 
1503 |     if (payload._status === Resolved) {
1504 |       return payload._result;
1505 |     } else {
1506 |       throw payload._result;
1507 |     }
1508 |   }
1509 | 
1510 |   function lazy(ctor) {
1511 |     var payload = {
1512 |       // We use these fields to store the result.
1513 |       _status: -1,
1514 |       _result: ctor,
1515 |     };
1516 |     var lazyType = {
1517 |       $$typeof: REACT_LAZY_TYPE,
1518 |       _payload: payload,
1519 |       _init: lazyInitializer,
1520 |     };
1521 | 
1522 |     {
1523 |       // In production, this would just set it on the object.
1524 |       var defaultProps;
1525 |       var propTypes; // $FlowFixMe
1526 | 
1527 |       Object.defineProperties(lazyType, {
1528 |         defaultProps: {
1529 |           configurable: true,
1530 |           get: function () {
1531 |             return defaultProps;
1532 |           },
1533 |           set: function (newDefaultProps) {
1534 |             error(
1535 |               "React.lazy(...): It is not supported to assign `defaultProps` to " +
1536 |                 "a lazy component import. Either specify them where the component " +
1537 |                 "is defined, or create a wrapping component around it."
1538 |             );
1539 | 
1540 |             defaultProps = newDefaultProps; // Match production behavior more closely:
1541 |             // $FlowFixMe
1542 | 
1543 |             Object.defineProperty(lazyType, "defaultProps", {
1544 |               enumerable: true,
1545 |             });
1546 |           },
1547 |         },
1548 |         propTypes: {
1549 |           configurable: true,
1550 |           get: function () {
1551 |             return propTypes;
1552 |           },
1553 |           set: function (newPropTypes) {
1554 |             error(
1555 |               "React.lazy(...): It is not supported to assign `propTypes` to " +
1556 |                 "a lazy component import. Either specify them where the component " +
1557 |                 "is defined, or create a wrapping component around it."
1558 |             );
1559 | 
1560 |             propTypes = newPropTypes; // Match production behavior more closely:
1561 |             // $FlowFixMe
1562 | 
1563 |             Object.defineProperty(lazyType, "propTypes", {
1564 |               enumerable: true,
1565 |             });
1566 |           },
1567 |         },
1568 |       });
1569 |     }
1570 | 
1571 |     return lazyType;
1572 |   }
1573 | 
1574 |   function forwardRef(render) {
1575 |     {
1576 |       if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
1577 |         error(
1578 |           "forwardRef requires a render function but received a `memo` " +
1579 |             "component. Instead of forwardRef(memo(...)), use " +
1580 |             "memo(forwardRef(...))."
1581 |         );
1582 |       } else if (typeof render !== "function") {
1583 |         error(
1584 |           "forwardRef requires a render function but was given %s.",
1585 |           render === null ? "null" : typeof render
1586 |         );
1587 |       } else {
1588 |         if (render.length !== 0 && render.length !== 2) {
1589 |           error(
1590 |             "forwardRef render functions accept exactly two parameters: props and ref. %s",
1591 |             render.length === 1
1592 |               ? "Did you forget to use the ref parameter?"
1593 |               : "Any additional parameter will be undefined."
1594 |           );
1595 |         }
1596 |       }
1597 | 
1598 |       if (render != null) {
1599 |         if (render.defaultProps != null || render.propTypes != null) {
1600 |           error(
1601 |             "forwardRef render functions do not support propTypes or defaultProps. " +
1602 |               "Did you accidentally pass a React component?"
1603 |           );
1604 |         }
1605 |       }
1606 |     }
1607 | 
1608 |     var elementType = {
1609 |       $$typeof: REACT_FORWARD_REF_TYPE,
1610 |       render: render,
1611 |     };
1612 | 
1613 |     {
1614 |       var ownName;
1615 |       Object.defineProperty(elementType, "displayName", {
1616 |         enumerable: false,
1617 |         configurable: true,
1618 |         get: function () {
1619 |           return ownName;
1620 |         },
1621 |         set: function (name) {
1622 |           ownName = name;
1623 | 
1624 |           if (render.displayName == null) {
1625 |             render.displayName = name;
1626 |           }
1627 |         },
1628 |       });
1629 |     }
1630 | 
1631 |     return elementType;
1632 |   }
1633 | 
1634 |   // Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
1635 | 
1636 |   var enableScopeAPI = false; // Experimental Create Event Handle API.
1637 | 
1638 |   function isValidElementType(type) {
1639 |     if (typeof type === "string" || typeof type === "function") {
1640 |       return true;
1641 |     } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
1642 | 
1643 |     if (
1644 |       type === exports.Fragment ||
1645 |       type === exports.Profiler ||
1646 |       type === REACT_DEBUG_TRACING_MODE_TYPE ||
1647 |       type === exports.StrictMode ||
1648 |       type === exports.Suspense ||
1649 |       type === REACT_SUSPENSE_LIST_TYPE ||
1650 |       type === REACT_LEGACY_HIDDEN_TYPE ||
1651 |       enableScopeAPI
1652 |     ) {
1653 |       return true;
1654 |     }
1655 | 
1656 |     if (typeof type === "object" && type !== null) {
1657 |       if (
1658 |         type.$$typeof === REACT_LAZY_TYPE ||
1659 |         type.$$typeof === REACT_MEMO_TYPE ||
1660 |         type.$$typeof === REACT_PROVIDER_TYPE ||
1661 |         type.$$typeof === REACT_CONTEXT_TYPE ||
1662 |         type.$$typeof === REACT_FORWARD_REF_TYPE ||
1663 |         type.$$typeof === REACT_FUNDAMENTAL_TYPE ||
1664 |         type.$$typeof === REACT_BLOCK_TYPE ||
1665 |         type[0] === REACT_SERVER_BLOCK_TYPE
1666 |       ) {
1667 |         return true;
1668 |       }
1669 |     }
1670 | 
1671 |     return false;
1672 |   }
1673 | 
1674 |   function memo(type, compare) {
1675 |     {
1676 |       if (!isValidElementType(type)) {
1677 |         error(
1678 |           "memo: The first argument must be a component. Instead " +
1679 |             "received: %s",
1680 |           type === null ? "null" : typeof type
1681 |         );
1682 |       }
1683 |     }
1684 | 
1685 |     var elementType = {
1686 |       $$typeof: REACT_MEMO_TYPE,
1687 |       type: type,
1688 |       compare: compare === undefined ? null : compare,
1689 |     };
1690 | 
1691 |     {
1692 |       var ownName;
1693 |       Object.defineProperty(elementType, "displayName", {
1694 |         enumerable: false,
1695 |         configurable: true,
1696 |         get: function () {
1697 |           return ownName;
1698 |         },
1699 |         set: function (name) {
1700 |           ownName = name;
1701 | 
1702 |           if (type.displayName == null) {
1703 |             type.displayName = name;
1704 |           }
1705 |         },
1706 |       });
1707 |     }
1708 | 
1709 |     return elementType;
1710 |   }
1711 | 
1712 |   function resolveDispatcher() {
1713 |     var dispatcher = ReactCurrentDispatcher.current;
1714 | 
1715 |     if (!(dispatcher !== null)) {
1716 |       {
1717 |         throw Error(
1718 |           "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem."
1719 |         );
1720 |       }
1721 |     }
1722 | 
1723 |     return dispatcher;
1724 |   }
1725 | 
1726 |   function useContext(Context, unstable_observedBits) {
1727 |     var dispatcher = resolveDispatcher();
1728 | 
1729 |     {
1730 |       if (unstable_observedBits !== undefined) {
1731 |         error(
1732 |           "useContext() second argument is reserved for future " +
1733 |             "use in React. Passing it is not supported. " +
1734 |             "You passed: %s.%s",
1735 |           unstable_observedBits,
1736 |           typeof unstable_observedBits === "number" &&
1737 |             Array.isArray(arguments[2])
1738 |             ? "\n\nDid you call array.map(useContext)? " +
1739 |                 "Calling Hooks inside a loop is not supported. " +
1740 |                 "Learn more at https://reactjs.org/link/rules-of-hooks"
1741 |             : ""
1742 |         );
1743 |       } // TODO: add a more generic warning for invalid values.
1744 | 
1745 |       if (Context._context !== undefined) {
1746 |         var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
1747 |         // and nobody should be using this in existing code.
1748 | 
1749 |         if (realContext.Consumer === Context) {
1750 |           error(
1751 |             "Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be " +
1752 |               "removed in a future major release. Did you mean to call useContext(Context) instead?"
1753 |           );
1754 |         } else if (realContext.Provider === Context) {
1755 |           error(
1756 |             "Calling useContext(Context.Provider) is not supported. " +
1757 |               "Did you mean to call useContext(Context) instead?"
1758 |           );
1759 |         }
1760 |       }
1761 |     }
1762 | 
1763 |     return dispatcher.useContext(Context, unstable_observedBits);
1764 |   }
1765 |   function useState(initialState) {
1766 |     var dispatcher = resolveDispatcher();
1767 |     return dispatcher.useState(initialState);
1768 |   }
1769 |   function useReducer(reducer, initialArg, init) {
1770 |     var dispatcher = resolveDispatcher();
1771 |     return dispatcher.useReducer(reducer, initialArg, init);
1772 |   }
1773 |   function useRef(initialValue) {
1774 |     var dispatcher = resolveDispatcher();
1775 |     return dispatcher.useRef(initialValue);
1776 |   }
1777 |   function useEffect(create, deps) {
1778 |     var dispatcher = resolveDispatcher();
1779 |     return dispatcher.useEffect(create, deps);
1780 |   }
1781 |   function useLayoutEffect(create, deps) {
1782 |     var dispatcher = resolveDispatcher();
1783 |     return dispatcher.useLayoutEffect(create, deps);
1784 |   }
1785 |   function useCallback(callback, deps) {
1786 |     var dispatcher = resolveDispatcher();
1787 |     return dispatcher.useCallback(callback, deps);
1788 |   }
1789 |   function useMemo(create, deps) {
1790 |     var dispatcher = resolveDispatcher();
1791 |     return dispatcher.useMemo(create, deps);
1792 |   }
1793 |   function useImperativeHandle(ref, create, deps) {
1794 |     var dispatcher = resolveDispatcher();
1795 |     return dispatcher.useImperativeHandle(ref, create, deps);
1796 |   }
1797 |   function useDebugValue(value, formatterFn) {
1798 |     {
1799 |       var dispatcher = resolveDispatcher();
1800 |       return dispatcher.useDebugValue(value, formatterFn);
1801 |     }
1802 |   }
1803 | 
1804 |   // Helpers to patch console.logs to avoid logging during side-effect free
1805 |   // replaying on render function. This currently only patches the object
1806 |   // lazily which won't cover if the log function was extracted eagerly.
1807 |   // We could also eagerly patch the method.
1808 |   var disabledDepth = 0;
1809 |   var prevLog;
1810 |   var prevInfo;
1811 |   var prevWarn;
1812 |   var prevError;
1813 |   var prevGroup;
1814 |   var prevGroupCollapsed;
1815 |   var prevGroupEnd;
1816 | 
1817 |   function disabledLog() {}
1818 | 
1819 |   disabledLog.__reactDisabledLog = true;
1820 |   function disableLogs() {
1821 |     {
1822 |       if (disabledDepth === 0) {
1823 |         /* eslint-disable react-internal/no-production-logging */
1824 |         prevLog = console.log;
1825 |         prevInfo = console.info;
1826 |         prevWarn = console.warn;
1827 |         prevError = console.error;
1828 |         prevGroup = console.group;
1829 |         prevGroupCollapsed = console.groupCollapsed;
1830 |         prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
1831 | 
1832 |         var props = {
1833 |           configurable: true,
1834 |           enumerable: true,
1835 |           value: disabledLog,
1836 |           writable: true,
1837 |         }; // $FlowFixMe Flow thinks console is immutable.
1838 | 
1839 |         Object.defineProperties(console, {
1840 |           info: props,
1841 |           log: props,
1842 |           warn: props,
1843 |           error: props,
1844 |           group: props,
1845 |           groupCollapsed: props,
1846 |           groupEnd: props,
1847 |         });
1848 |         /* eslint-enable react-internal/no-production-logging */
1849 |       }
1850 | 
1851 |       disabledDepth++;
1852 |     }
1853 |   }
1854 |   function reenableLogs() {
1855 |     {
1856 |       disabledDepth--;
1857 | 
1858 |       if (disabledDepth === 0) {
1859 |         /* eslint-disable react-internal/no-production-logging */
1860 |         var props = {
1861 |           configurable: true,
1862 |           enumerable: true,
1863 |           writable: true,
1864 |         }; // $FlowFixMe Flow thinks console is immutable.
1865 | 
1866 |         Object.defineProperties(console, {
1867 |           log: assign({}, props, {
1868 |             value: prevLog,
1869 |           }),
1870 |           info: assign({}, props, {
1871 |             value: prevInfo,
1872 |           }),
1873 |           warn: assign({}, props, {
1874 |             value: prevWarn,
1875 |           }),
1876 |           error: assign({}, props, {
1877 |             value: prevError,
1878 |           }),
1879 |           group: assign({}, props, {
1880 |             value: prevGroup,
1881 |           }),
1882 |           groupCollapsed: assign({}, props, {
1883 |             value: prevGroupCollapsed,
1884 |           }),
1885 |           groupEnd: assign({}, props, {
1886 |             value: prevGroupEnd,
1887 |           }),
1888 |         });
1889 |         /* eslint-enable react-internal/no-production-logging */
1890 |       }
1891 | 
1892 |       if (disabledDepth < 0) {
1893 |         error(
1894 |           "disabledDepth fell below zero. " +
1895 |             "This is a bug in React. Please file an issue."
1896 |         );
1897 |       }
1898 |     }
1899 |   }
1900 | 
1901 |   var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
1902 |   var prefix;
1903 |   function describeBuiltInComponentFrame(name, source, ownerFn) {
1904 |     {
1905 |       if (prefix === undefined) {
1906 |         // Extract the VM specific prefix used by each line.
1907 |         try {
1908 |           throw Error();
1909 |         } catch (x) {
1910 |           var match = x.stack.trim().match(/\n( *(at )?)/);
1911 |           prefix = (match && match[1]) || "";
1912 |         }
1913 |       } // We use the prefix to ensure our stacks line up with native stack frames.
1914 | 
1915 |       return "\n" + prefix + name;
1916 |     }
1917 |   }
1918 |   var reentry = false;
1919 |   var componentFrameCache;
1920 | 
1921 |   {
1922 |     var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
1923 |     componentFrameCache = new PossiblyWeakMap();
1924 |   }
1925 | 
1926 |   function describeNativeComponentFrame(fn, construct) {
1927 |     // If something asked for a stack inside a fake render, it should get ignored.
1928 |     if (!fn || reentry) {
1929 |       return "";
1930 |     }
1931 | 
1932 |     {
1933 |       var frame = componentFrameCache.get(fn);
1934 | 
1935 |       if (frame !== undefined) {
1936 |         return frame;
1937 |       }
1938 |     }
1939 | 
1940 |     var control;
1941 |     reentry = true;
1942 |     var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
1943 | 
1944 |     Error.prepareStackTrace = undefined;
1945 |     var previousDispatcher;
1946 | 
1947 |     {
1948 |       previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
1949 |       // for warnings.
1950 | 
1951 |       ReactCurrentDispatcher$1.current = null;
1952 |       disableLogs();
1953 |     }
1954 | 
1955 |     try {
1956 |       // This should throw.
1957 |       if (construct) {
1958 |         // Something should be setting the props in the constructor.
1959 |         var Fake = function () {
1960 |           throw Error();
1961 |         }; // $FlowFixMe
1962 | 
1963 |         Object.defineProperty(Fake.prototype, "props", {
1964 |           set: function () {
1965 |             // We use a throwing setter instead of frozen or non-writable props
1966 |             // because that won't throw in a non-strict mode function.
1967 |             throw Error();
1968 |           },
1969 |         });
1970 | 
1971 |         if (typeof Reflect === "object" && Reflect.construct) {
1972 |           // We construct a different control for this case to include any extra
1973 |           // frames added by the construct call.
1974 |           try {
1975 |             Reflect.construct(Fake, []);
1976 |           } catch (x) {
1977 |             control = x;
1978 |           }
1979 | 
1980 |           Reflect.construct(fn, [], Fake);
1981 |         } else {
1982 |           try {
1983 |             Fake.call();
1984 |           } catch (x) {
1985 |             control = x;
1986 |           }
1987 | 
1988 |           fn.call(Fake.prototype);
1989 |         }
1990 |       } else {
1991 |         try {
1992 |           throw Error();
1993 |         } catch (x) {
1994 |           control = x;
1995 |         }
1996 | 
1997 |         fn();
1998 |       }
1999 |     } catch (sample) {
2000 |       // This is inlined manually because closure doesn't do it for us.
2001 |       if (sample && control && typeof sample.stack === "string") {
2002 |         // This extracts the first frame from the sample that isn't also in the control.
2003 |         // Skipping one frame that we assume is the frame that calls the two.
2004 |         var sampleLines = sample.stack.split("\n");
2005 |         var controlLines = control.stack.split("\n");
2006 |         var s = sampleLines.length - 1;
2007 |         var c = controlLines.length - 1;
2008 | 
2009 |         while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
2010 |           // We expect at least one stack frame to be shared.
2011 |           // Typically this will be the root most one. However, stack frames may be
2012 |           // cut off due to maximum stack limits. In this case, one maybe cut off
2013 |           // earlier than the other. We assume that the sample is longer or the same
2014 |           // and there for cut off earlier. So we should find the root most frame in
2015 |           // the sample somewhere in the control.
2016 |           c--;
2017 |         }
2018 | 
2019 |         for (; s >= 1 && c >= 0; s--, c--) {
2020 |           // Next we find the first one that isn't the same which should be the
2021 |           // frame that called our sample function and the control.
2022 |           if (sampleLines[s] !== controlLines[c]) {
2023 |             // In V8, the first line is describing the message but other VMs don't.
2024 |             // If we're about to return the first line, and the control is also on the same
2025 |             // line, that's a pretty good indicator that our sample threw at same line as
2026 |             // the control. I.e. before we entered the sample frame. So we ignore this result.
2027 |             // This can happen if you passed a class to function component, or non-function.
2028 |             if (s !== 1 || c !== 1) {
2029 |               do {
2030 |                 s--;
2031 |                 c--; // We may still have similar intermediate frames from the construct call.
2032 |                 // The next one that isn't the same should be our match though.
2033 | 
2034 |                 if (c < 0 || sampleLines[s] !== controlLines[c]) {
2035 |                   // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
2036 |                   var _frame =
2037 |                     "\n" + sampleLines[s].replace(" at new ", " at ");
2038 | 
2039 |                   {
2040 |                     if (typeof fn === "function") {
2041 |                       componentFrameCache.set(fn, _frame);
2042 |                     }
2043 |                   } // Return the line we found.
2044 | 
2045 |                   return _frame;
2046 |                 }
2047 |               } while (s >= 1 && c >= 0);
2048 |             }
2049 | 
2050 |             break;
2051 |           }
2052 |         }
2053 |       }
2054 |     } finally {
2055 |       reentry = false;
2056 | 
2057 |       {
2058 |         ReactCurrentDispatcher$1.current = previousDispatcher;
2059 |         reenableLogs();
2060 |       }
2061 | 
2062 |       Error.prepareStackTrace = previousPrepareStackTrace;
2063 |     } // Fallback to just using the name if we couldn't make it throw.
2064 | 
2065 |     var name = fn ? fn.displayName || fn.name : "";
2066 |     var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
2067 | 
2068 |     {
2069 |       if (typeof fn === "function") {
2070 |         componentFrameCache.set(fn, syntheticFrame);
2071 |       }
2072 |     }
2073 | 
2074 |     return syntheticFrame;
2075 |   }
2076 |   function describeFunctionComponentFrame(fn, source, ownerFn) {
2077 |     {
2078 |       return describeNativeComponentFrame(fn, false);
2079 |     }
2080 |   }
2081 | 
2082 |   function shouldConstruct(Component) {
2083 |     var prototype = Component.prototype;
2084 |     return !!(prototype && prototype.isReactComponent);
2085 |   }
2086 | 
2087 |   function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
2088 |     if (type == null) {
2089 |       return "";
2090 |     }
2091 | 
2092 |     if (typeof type === "function") {
2093 |       {
2094 |         return describeNativeComponentFrame(type, shouldConstruct(type));
2095 |       }
2096 |     }
2097 | 
2098 |     if (typeof type === "string") {
2099 |       return describeBuiltInComponentFrame(type);
2100 |     }
2101 | 
2102 |     switch (type) {
2103 |       case exports.Suspense:
2104 |         return describeBuiltInComponentFrame("Suspense");
2105 | 
2106 |       case REACT_SUSPENSE_LIST_TYPE:
2107 |         return describeBuiltInComponentFrame("SuspenseList");
2108 |     }
2109 | 
2110 |     if (typeof type === "object") {
2111 |       switch (type.$$typeof) {
2112 |         case REACT_FORWARD_REF_TYPE:
2113 |           return describeFunctionComponentFrame(type.render);
2114 | 
2115 |         case REACT_MEMO_TYPE:
2116 |           // Memo may contain any component type so we recursively resolve it.
2117 |           return describeUnknownElementTypeFrameInDEV(
2118 |             type.type,
2119 |             source,
2120 |             ownerFn
2121 |           );
2122 | 
2123 |         case REACT_BLOCK_TYPE:
2124 |           return describeFunctionComponentFrame(type._render);
2125 | 
2126 |         case REACT_LAZY_TYPE: {
2127 |           var lazyComponent = type;
2128 |           var payload = lazyComponent._payload;
2129 |           var init = lazyComponent._init;
2130 | 
2131 |           try {
2132 |             // Lazy may contain any component type so we recursively resolve it.
2133 |             return describeUnknownElementTypeFrameInDEV(
2134 |               init(payload),
2135 |               source,
2136 |               ownerFn
2137 |             );
2138 |           } catch (x) {}
2139 |         }
2140 |       }
2141 |     }
2142 | 
2143 |     return "";
2144 |   }
2145 | 
2146 |   var loggedTypeFailures = {};
2147 |   var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
2148 | 
2149 |   function setCurrentlyValidatingElement(element) {
2150 |     {
2151 |       if (element) {
2152 |         var owner = element._owner;
2153 |         var stack = describeUnknownElementTypeFrameInDEV(
2154 |           element.type,
2155 |           element._source,
2156 |           owner ? owner.type : null
2157 |         );
2158 |         ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
2159 |       } else {
2160 |         ReactDebugCurrentFrame$1.setExtraStackFrame(null);
2161 |       }
2162 |     }
2163 |   }
2164 | 
2165 |   function checkPropTypes(typeSpecs, values, location, componentName, element) {
2166 |     {
2167 |       // $FlowFixMe This is okay but Flow doesn't know it.
2168 |       var has = Function.call.bind(Object.prototype.hasOwnProperty);
2169 | 
2170 |       for (var typeSpecName in typeSpecs) {
2171 |         if (has(typeSpecs, typeSpecName)) {
2172 |           var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
2173 |           // fail the render phase where it didn't fail before. So we log it.
2174 |           // After these have been cleaned up, we'll let them throw.
2175 | 
2176 |           try {
2177 |             // This is intentionally an invariant that gets caught. It's the same
2178 |             // behavior as without this statement except with a better message.
2179 |             if (typeof typeSpecs[typeSpecName] !== "function") {
2180 |               var err = Error(
2181 |                 (componentName || "React class") +
2182 |                   ": " +
2183 |                   location +
2184 |                   " type `" +
2185 |                   typeSpecName +
2186 |                   "` is invalid; " +
2187 |                   "it must be a function, usually from the `prop-types` package, but received `" +
2188 |                   typeof typeSpecs[typeSpecName] +
2189 |                   "`." +
2190 |                   "This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
2191 |               );
2192 |               err.name = "Invariant Violation";
2193 |               throw err;
2194 |             }
2195 | 
2196 |             error$1 = typeSpecs[typeSpecName](
2197 |               values,
2198 |               typeSpecName,
2199 |               componentName,
2200 |               location,
2201 |               null,
2202 |               "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED"
2203 |             );
2204 |           } catch (ex) {
2205 |             error$1 = ex;
2206 |           }
2207 | 
2208 |           if (error$1 && !(error$1 instanceof Error)) {
2209 |             setCurrentlyValidatingElement(element);
2210 | 
2211 |             error(
2212 |               "%s: type specification of %s" +
2213 |                 " `%s` is invalid; the type checker " +
2214 |                 "function must return `null` or an `Error` but returned a %s. " +
2215 |                 "You may have forgotten to pass an argument to the type checker " +
2216 |                 "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
2217 |                 "shape all require an argument).",
2218 |               componentName || "React class",
2219 |               location,
2220 |               typeSpecName,
2221 |               typeof error$1
2222 |             );
2223 | 
2224 |             setCurrentlyValidatingElement(null);
2225 |           }
2226 | 
2227 |           if (
2228 |             error$1 instanceof Error &&
2229 |             !(error$1.message in loggedTypeFailures)
2230 |           ) {
2231 |             // Only monitor this failure once because there tends to be a lot of the
2232 |             // same error.
2233 |             loggedTypeFailures[error$1.message] = true;
2234 |             setCurrentlyValidatingElement(element);
2235 | 
2236 |             error("Failed %s type: %s", location, error$1.message);
2237 | 
2238 |             setCurrentlyValidatingElement(null);
2239 |           }
2240 |         }
2241 |       }
2242 |     }
2243 |   }
2244 | 
2245 |   function setCurrentlyValidatingElement$1(element) {
2246 |     {
2247 |       if (element) {
2248 |         var owner = element._owner;
2249 |         var stack = describeUnknownElementTypeFrameInDEV(
2250 |           element.type,
2251 |           element._source,
2252 |           owner ? owner.type : null
2253 |         );
2254 |         setExtraStackFrame(stack);
2255 |       } else {
2256 |         setExtraStackFrame(null);
2257 |       }
2258 |     }
2259 |   }
2260 | 
2261 |   var propTypesMisspellWarningShown;
2262 | 
2263 |   {
2264 |     propTypesMisspellWarningShown = false;
2265 |   }
2266 | 
2267 |   function getDeclarationErrorAddendum() {
2268 |     if (ReactCurrentOwner.current) {
2269 |       var name = getComponentName(ReactCurrentOwner.current.type);
2270 | 
2271 |       if (name) {
2272 |         return "\n\nCheck the render method of `" + name + "`.";
2273 |       }
2274 |     }
2275 | 
2276 |     return "";
2277 |   }
2278 | 
2279 |   function getSourceInfoErrorAddendum(source) {
2280 |     if (source !== undefined) {
2281 |       var fileName = source.fileName.replace(/^.*[\\\/]/, "");
2282 |       var lineNumber = source.lineNumber;
2283 |       return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
2284 |     }
2285 | 
2286 |     return "";
2287 |   }
2288 | 
2289 |   function getSourceInfoErrorAddendumForProps(elementProps) {
2290 |     if (elementProps !== null && elementProps !== undefined) {
2291 |       return getSourceInfoErrorAddendum(elementProps.__source);
2292 |     }
2293 | 
2294 |     return "";
2295 |   }
2296 |   /**
2297 |    * Warn if there's no key explicitly set on dynamic arrays of children or
2298 |    * object keys are not valid. This allows us to keep track of children between
2299 |    * updates.
2300 |    */
2301 | 
2302 |   var ownerHasKeyUseWarning = {};
2303 | 
2304 |   function getCurrentComponentErrorInfo(parentType) {
2305 |     var info = getDeclarationErrorAddendum();
2306 | 
2307 |     if (!info) {
2308 |       var parentName =
2309 |         typeof parentType === "string"
2310 |           ? parentType
2311 |           : parentType.displayName || parentType.name;
2312 | 
2313 |       if (parentName) {
2314 |         info =
2315 |           "\n\nCheck the top-level render call using <" + parentName + ">.";
2316 |       }
2317 |     }
2318 | 
2319 |     return info;
2320 |   }
2321 |   /**
2322 |    * Warn if the element doesn't have an explicit key assigned to it.
2323 |    * This element is in an array. The array could grow and shrink or be
2324 |    * reordered. All children that haven't already been validated are required to
2325 |    * have a "key" property assigned to it. Error statuses are cached so a warning
2326 |    * will only be shown once.
2327 |    *
2328 |    * @internal
2329 |    * @param {ReactElement} element Element that requires a key.
2330 |    * @param {*} parentType element's parent's type.
2331 |    */
2332 | 
2333 |   function validateExplicitKey(element, parentType) {
2334 |     if (!element._store || element._store.validated || element.key != null) {
2335 |       return;
2336 |     }
2337 | 
2338 |     element._store.validated = true;
2339 |     var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
2340 | 
2341 |     if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
2342 |       return;
2343 |     }
2344 | 
2345 |     ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
2346 |     // property, it may be the creator of the child that's responsible for
2347 |     // assigning it a key.
2348 | 
2349 |     var childOwner = "";
2350 | 
2351 |     if (
2352 |       element &&
2353 |       element._owner &&
2354 |       element._owner !== ReactCurrentOwner.current
2355 |     ) {
2356 |       // Give the component that originally created this child.
2357 |       childOwner =
2358 |         " It was passed a child from " +
2359 |         getComponentName(element._owner.type) +
2360 |         ".";
2361 |     }
2362 | 
2363 |     {
2364 |       setCurrentlyValidatingElement$1(element);
2365 | 
2366 |       error(
2367 |         'Each child in a list should have a unique "key" prop.' +
2368 |           "%s%s See https://reactjs.org/link/warning-keys for more information.",
2369 |         currentComponentErrorInfo,
2370 |         childOwner
2371 |       );
2372 | 
2373 |       setCurrentlyValidatingElement$1(null);
2374 |     }
2375 |   }
2376 |   /**
2377 |    * Ensure that every element either is passed in a static location, in an
2378 |    * array with an explicit keys property defined, or in an object literal
2379 |    * with valid key property.
2380 |    *
2381 |    * @internal
2382 |    * @param {ReactNode} node Statically passed child of any type.
2383 |    * @param {*} parentType node's parent's type.
2384 |    */
2385 | 
2386 |   function validateChildKeys(node, parentType) {
2387 |     if (typeof node !== "object") {
2388 |       return;
2389 |     }
2390 | 
2391 |     if (Array.isArray(node)) {
2392 |       for (var i = 0; i < node.length; i++) {
2393 |         var child = node[i];
2394 | 
2395 |         if (isValidElement(child)) {
2396 |           validateExplicitKey(child, parentType);
2397 |         }
2398 |       }
2399 |     } else if (isValidElement(node)) {
2400 |       // This element was passed in a valid location.
2401 |       if (node._store) {
2402 |         node._store.validated = true;
2403 |       }
2404 |     } else if (node) {
2405 |       var iteratorFn = getIteratorFn(node);
2406 | 
2407 |       if (typeof iteratorFn === "function") {
2408 |         // Entry iterators used to provide implicit keys,
2409 |         // but now we print a separate warning for them later.
2410 |         if (iteratorFn !== node.entries) {
2411 |           var iterator = iteratorFn.call(node);
2412 |           var step;
2413 | 
2414 |           while (!(step = iterator.next()).done) {
2415 |             if (isValidElement(step.value)) {
2416 |               validateExplicitKey(step.value, parentType);
2417 |             }
2418 |           }
2419 |         }
2420 |       }
2421 |     }
2422 |   }
2423 |   /**
2424 |    * Given an element, validate that its props follow the propTypes definition,
2425 |    * provided by the type.
2426 |    *
2427 |    * @param {ReactElement} element
2428 |    */
2429 | 
2430 |   function validatePropTypes(element) {
2431 |     {
2432 |       var type = element.type;
2433 | 
2434 |       if (type === null || type === undefined || typeof type === "string") {
2435 |         return;
2436 |       }
2437 | 
2438 |       var propTypes;
2439 | 
2440 |       if (typeof type === "function") {
2441 |         propTypes = type.propTypes;
2442 |       } else if (
2443 |         typeof type === "object" &&
2444 |         (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
2445 |           // Inner props are checked in the reconciler.
2446 |           type.$$typeof === REACT_MEMO_TYPE)
2447 |       ) {
2448 |         propTypes = type.propTypes;
2449 |       } else {
2450 |         return;
2451 |       }
2452 | 
2453 |       if (propTypes) {
2454 |         // Intentionally inside to avoid triggering lazy initializers:
2455 |         var name = getComponentName(type);
2456 |         checkPropTypes(propTypes, element.props, "prop", name, element);
2457 |       } else if (
2458 |         type.PropTypes !== undefined &&
2459 |         !propTypesMisspellWarningShown
2460 |       ) {
2461 |         propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
2462 | 
2463 |         var _name = getComponentName(type);
2464 | 
2465 |         error(
2466 |           "Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?",
2467 |           _name || "Unknown"
2468 |         );
2469 |       }
2470 | 
2471 |       if (
2472 |         typeof type.getDefaultProps === "function" &&
2473 |         !type.getDefaultProps.isReactClassApproved
2474 |       ) {
2475 |         error(
2476 |           "getDefaultProps is only used on classic React.createClass " +
2477 |             "definitions. Use a static property named `defaultProps` instead."
2478 |         );
2479 |       }
2480 |     }
2481 |   }
2482 |   /**
2483 |    * Given a fragment, validate that it can only be provided with fragment props
2484 |    * @param {ReactElement} fragment
2485 |    */
2486 | 
2487 |   function validateFragmentProps(fragment) {
2488 |     {
2489 |       var keys = Object.keys(fragment.props);
2490 | 
2491 |       for (var i = 0; i < keys.length; i++) {
2492 |         var key = keys[i];
2493 | 
2494 |         if (key !== "children" && key !== "key") {
2495 |           setCurrentlyValidatingElement$1(fragment);
2496 | 
2497 |           error(
2498 |             "Invalid prop `%s` supplied to `React.Fragment`. " +
2499 |               "React.Fragment can only have `key` and `children` props.",
2500 |             key
2501 |           );
2502 | 
2503 |           setCurrentlyValidatingElement$1(null);
2504 |           break;
2505 |         }
2506 |       }
2507 | 
2508 |       if (fragment.ref !== null) {
2509 |         setCurrentlyValidatingElement$1(fragment);
2510 | 
2511 |         error("Invalid attribute `ref` supplied to `React.Fragment`.");
2512 | 
2513 |         setCurrentlyValidatingElement$1(null);
2514 |       }
2515 |     }
2516 |   }
2517 |   function createElementWithValidation(type, props, children) {
2518 |     var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
2519 |     // succeed and there will likely be errors in render.
2520 | 
2521 |     if (!validType) {
2522 |       var info = "";
2523 | 
2524 |       if (
2525 |         type === undefined ||
2526 |         (typeof type === "object" &&
2527 |           type !== null &&
2528 |           Object.keys(type).length === 0)
2529 |       ) {
2530 |         info +=
2531 |           " You likely forgot to export your component from the file " +
2532 |           "it's defined in, or you might have mixed up default and named imports.";
2533 |       }
2534 | 
2535 |       var sourceInfo = getSourceInfoErrorAddendumForProps(props);
2536 | 
2537 |       if (sourceInfo) {
2538 |         info += sourceInfo;
2539 |       } else {
2540 |         info += getDeclarationErrorAddendum();
2541 |       }
2542 | 
2543 |       var typeString;
2544 | 
2545 |       if (type === null) {
2546 |         typeString = "null";
2547 |       } else if (Array.isArray(type)) {
2548 |         typeString = "array";
2549 |       } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
2550 |         typeString = "<" + (getComponentName(type.type) || "Unknown") + " />";
2551 |         info =
2552 |           " Did you accidentally export a JSX literal instead of a component?";
2553 |       } else {
2554 |         typeString = typeof type;
2555 |       }
2556 | 
2557 |       {
2558 |         error(
2559 |           "React.createElement: type is invalid -- expected a string (for " +
2560 |             "built-in components) or a class/function (for composite " +
2561 |             "components) but got: %s.%s",
2562 |           typeString,
2563 |           info
2564 |         );
2565 |       }
2566 |     }
2567 | 
2568 |     var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
2569 |     // TODO: Drop this when these are no longer allowed as the type argument.
2570 | 
2571 |     if (element == null) {
2572 |       return element;
2573 |     } // Skip key warning if the type isn't valid since our key validation logic
2574 |     // doesn't expect a non-string/function type and can throw confusing errors.
2575 |     // We don't want exception behavior to differ between dev and prod.
2576 |     // (Rendering will throw with a helpful message and as soon as the type is
2577 |     // fixed, the key warnings will appear.)
2578 | 
2579 |     if (validType) {
2580 |       for (var i = 2; i < arguments.length; i++) {
2581 |         validateChildKeys(arguments[i], type);
2582 |       }
2583 |     }
2584 | 
2585 |     if (type === exports.Fragment) {
2586 |       validateFragmentProps(element);
2587 |     } else {
2588 |       validatePropTypes(element);
2589 |     }
2590 | 
2591 |     return element;
2592 |   }
2593 |   var didWarnAboutDeprecatedCreateFactory = false;
2594 |   function createFactoryWithValidation(type) {
2595 |     var validatedFactory = createElementWithValidation.bind(null, type);
2596 |     validatedFactory.type = type;
2597 | 
2598 |     {
2599 |       if (!didWarnAboutDeprecatedCreateFactory) {
2600 |         didWarnAboutDeprecatedCreateFactory = true;
2601 | 
2602 |         warn(
2603 |           "React.createFactory() is deprecated and will be removed in " +
2604 |             "a future major release. Consider using JSX " +
2605 |             "or use React.createElement() directly instead."
2606 |         );
2607 |       } // Legacy hook: remove it
2608 | 
2609 |       Object.defineProperty(validatedFactory, "type", {
2610 |         enumerable: false,
2611 |         get: function () {
2612 |           warn(
2613 |             "Factory.type is deprecated. Access the class directly " +
2614 |               "before passing it to createFactory."
2615 |           );
2616 | 
2617 |           Object.defineProperty(this, "type", {
2618 |             value: type,
2619 |           });
2620 |           return type;
2621 |         },
2622 |       });
2623 |     }
2624 | 
2625 |     return validatedFactory;
2626 |   }
2627 |   function cloneElementWithValidation(element, props, children) {
2628 |     var newElement = cloneElement.apply(this, arguments);
2629 | 
2630 |     for (var i = 2; i < arguments.length; i++) {
2631 |       validateChildKeys(arguments[i], newElement.type);
2632 |     }
2633 | 
2634 |     validatePropTypes(newElement);
2635 |     return newElement;
2636 |   }
2637 | 
2638 |   var enableSchedulerDebugging = false;
2639 |   var enableProfiling = false;
2640 | 
2641 |   var requestHostCallback;
2642 |   var requestHostTimeout;
2643 |   var cancelHostTimeout;
2644 |   var shouldYieldToHost;
2645 |   var requestPaint;
2646 |   var getCurrentTime;
2647 |   var forceFrameRate;
2648 |   var hasPerformanceNow =
2649 |     typeof performance === "object" && typeof performance.now === "function";
2650 | 
2651 |   if (hasPerformanceNow) {
2652 |     var localPerformance = performance;
2653 | 
2654 |     getCurrentTime = function () {
2655 |       return localPerformance.now();
2656 |     };
2657 |   } else {
2658 |     var localDate = Date;
2659 |     var initialTime = localDate.now();
2660 | 
2661 |     getCurrentTime = function () {
2662 |       return localDate.now() - initialTime;
2663 |     };
2664 |   }
2665 | 
2666 |   if (
2667 |     // If Scheduler runs in a non-DOM environment, it falls back to a naive
2668 |     // implementation using setTimeout.
2669 |     typeof window === "undefined" || // Check if MessageChannel is supported, too.
2670 |     typeof MessageChannel !== "function"
2671 |   ) {
2672 |     // If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
2673 |     // fallback to a naive implementation.
2674 |     var _callback = null;
2675 |     var _timeoutID = null;
2676 | 
2677 |     var _flushCallback = function () {
2678 |       if (_callback !== null) {
2679 |         try {
2680 |           var currentTime = getCurrentTime();
2681 |           var hasRemainingTime = true;
2682 | 
2683 |           _callback(hasRemainingTime, currentTime);
2684 | 
2685 |           _callback = null;
2686 |         } catch (e) {
2687 |           setTimeout(_flushCallback, 0);
2688 |           throw e;
2689 |         }
2690 |       }
2691 |     };
2692 | 
2693 |     requestHostCallback = function (cb) {
2694 |       if (_callback !== null) {
2695 |         // Protect against re-entrancy.
2696 |         setTimeout(requestHostCallback, 0, cb);
2697 |       } else {
2698 |         _callback = cb;
2699 |         setTimeout(_flushCallback, 0);
2700 |       }
2701 |     };
2702 | 
2703 |     requestHostTimeout = function (cb, ms) {
2704 |       _timeoutID = setTimeout(cb, ms);
2705 |     };
2706 | 
2707 |     cancelHostTimeout = function () {
2708 |       clearTimeout(_timeoutID);
2709 |     };
2710 | 
2711 |     shouldYieldToHost = function () {
2712 |       return false;
2713 |     };
2714 | 
2715 |     requestPaint = forceFrameRate = function () {};
2716 |   } else {
2717 |     // Capture local references to native APIs, in case a polyfill overrides them.
2718 |     var _setTimeout = window.setTimeout;
2719 |     var _clearTimeout = window.clearTimeout;
2720 | 
2721 |     if (typeof console !== "undefined") {
2722 |       // TODO: Scheduler no longer requires these methods to be polyfilled. But
2723 |       // maybe we want to continue warning if they don't exist, to preserve the
2724 |       // option to rely on it in the future?
2725 |       var requestAnimationFrame = window.requestAnimationFrame;
2726 |       var cancelAnimationFrame = window.cancelAnimationFrame;
2727 | 
2728 |       if (typeof requestAnimationFrame !== "function") {
2729 |         // Using console['error'] to evade Babel and ESLint
2730 |         console["error"](
2731 |           "This browser doesn't support requestAnimationFrame. " +
2732 |             "Make sure that you load a " +
2733 |             "polyfill in older browsers. https://reactjs.org/link/react-polyfills"
2734 |         );
2735 |       }
2736 | 
2737 |       if (typeof cancelAnimationFrame !== "function") {
2738 |         // Using console['error'] to evade Babel and ESLint
2739 |         console["error"](
2740 |           "This browser doesn't support cancelAnimationFrame. " +
2741 |             "Make sure that you load a " +
2742 |             "polyfill in older browsers. https://reactjs.org/link/react-polyfills"
2743 |         );
2744 |       }
2745 |     }
2746 | 
2747 |     var isMessageLoopRunning = false;
2748 |     var scheduledHostCallback = null;
2749 |     var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
2750 |     // thread, like user events. By default, it yields multiple times per frame.
2751 |     // It does not attempt to align with frame boundaries, since most tasks don't
2752 |     // need to be frame aligned; for those that do, use requestAnimationFrame.
2753 | 
2754 |     var yieldInterval = 5;
2755 |     var deadline = 0; // TODO: Make this configurable
2756 | 
2757 |     {
2758 |       // `isInputPending` is not available. Since we have no way of knowing if
2759 |       // there's pending input, always yield at the end of the frame.
2760 |       shouldYieldToHost = function () {
2761 |         return getCurrentTime() >= deadline;
2762 |       }; // Since we yield every frame regardless, `requestPaint` has no effect.
2763 | 
2764 |       requestPaint = function () {};
2765 |     }
2766 | 
2767 |     forceFrameRate = function (fps) {
2768 |       if (fps < 0 || fps > 125) {
2769 |         // Using console['error'] to evade Babel and ESLint
2770 |         console["error"](
2771 |           "forceFrameRate takes a positive int between 0 and 125, " +
2772 |             "forcing frame rates higher than 125 fps is not supported"
2773 |         );
2774 |         return;
2775 |       }
2776 | 
2777 |       if (fps > 0) {
2778 |         yieldInterval = Math.floor(1000 / fps);
2779 |       } else {
2780 |         // reset the framerate
2781 |         yieldInterval = 5;
2782 |       }
2783 |     };
2784 | 
2785 |     var performWorkUntilDeadline = function () {
2786 |       if (scheduledHostCallback !== null) {
2787 |         var currentTime = getCurrentTime(); // Yield after `yieldInterval` ms, regardless of where we are in the vsync
2788 |         // cycle. This means there's always time remaining at the beginning of
2789 |         // the message event.
2790 | 
2791 |         deadline = currentTime + yieldInterval;
2792 |         var hasTimeRemaining = true;
2793 | 
2794 |         try {
2795 |           var hasMoreWork = scheduledHostCallback(
2796 |             hasTimeRemaining,
2797 |             currentTime
2798 |           );
2799 | 
2800 |           if (!hasMoreWork) {
2801 |             isMessageLoopRunning = false;
2802 |             scheduledHostCallback = null;
2803 |           } else {
2804 |             // If there's more work, schedule the next message event at the end
2805 |             // of the preceding one.
2806 |             port.postMessage(null);
2807 |           }
2808 |         } catch (error) {
2809 |           // If a scheduler task throws, exit the current browser task so the
2810 |           // error can be observed.
2811 |           port.postMessage(null);
2812 |           throw error;
2813 |         }
2814 |       } else {
2815 |         isMessageLoopRunning = false;
2816 |       } // Yielding to the browser will give it a chance to paint, so we can
2817 |     };
2818 | 
2819 |     var channel = new MessageChannel();
2820 |     var port = channel.port2;
2821 |     channel.port1.onmessage = performWorkUntilDeadline;
2822 | 
2823 |     requestHostCallback = function (callback) {
2824 |       scheduledHostCallback = callback;
2825 | 
2826 |       if (!isMessageLoopRunning) {
2827 |         isMessageLoopRunning = true;
2828 |         port.postMessage(null);
2829 |       }
2830 |     };
2831 | 
2832 |     requestHostTimeout = function (callback, ms) {
2833 |       taskTimeoutID = _setTimeout(function () {
2834 |         callback(getCurrentTime());
2835 |       }, ms);
2836 |     };
2837 | 
2838 |     cancelHostTimeout = function () {
2839 |       _clearTimeout(taskTimeoutID);
2840 | 
2841 |       taskTimeoutID = -1;
2842 |     };
2843 |   }
2844 | 
2845 |   function push(heap, node) {
2846 |     var index = heap.length;
2847 |     heap.push(node);
2848 |     siftUp(heap, node, index);
2849 |   }
2850 |   function peek(heap) {
2851 |     var first = heap[0];
2852 |     return first === undefined ? null : first;
2853 |   }
2854 |   function pop(heap) {
2855 |     var first = heap[0];
2856 | 
2857 |     if (first !== undefined) {
2858 |       var last = heap.pop();
2859 | 
2860 |       if (last !== first) {
2861 |         heap[0] = last;
2862 |         siftDown(heap, last, 0);
2863 |       }
2864 | 
2865 |       return first;
2866 |     } else {
2867 |       return null;
2868 |     }
2869 |   }
2870 | 
2871 |   function siftUp(heap, node, i) {
2872 |     var index = i;
2873 | 
2874 |     while (true) {
2875 |       var parentIndex = (index - 1) >>> 1;
2876 |       var parent = heap[parentIndex];
2877 | 
2878 |       if (parent !== undefined && compare(parent, node) > 0) {
2879 |         // The parent is larger. Swap positions.
2880 |         heap[parentIndex] = node;
2881 |         heap[index] = parent;
2882 |         index = parentIndex;
2883 |       } else {
2884 |         // The parent is smaller. Exit.
2885 |         return;
2886 |       }
2887 |     }
2888 |   }
2889 | 
2890 |   function siftDown(heap, node, i) {
2891 |     var index = i;
2892 |     var length = heap.length;
2893 | 
2894 |     while (index < length) {
2895 |       var leftIndex = (index + 1) * 2 - 1;
2896 |       var left = heap[leftIndex];
2897 |       var rightIndex = leftIndex + 1;
2898 |       var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
2899 | 
2900 |       if (left !== undefined && compare(left, node) < 0) {
2901 |         if (right !== undefined && compare(right, left) < 0) {
2902 |           heap[index] = right;
2903 |           heap[rightIndex] = node;
2904 |           index = rightIndex;
2905 |         } else {
2906 |           heap[index] = left;
2907 |           heap[leftIndex] = node;
2908 |           index = leftIndex;
2909 |         }
2910 |       } else if (right !== undefined && compare(right, node) < 0) {
2911 |         heap[index] = right;
2912 |         heap[rightIndex] = node;
2913 |         index = rightIndex;
2914 |       } else {
2915 |         // Neither child is smaller. Exit.
2916 |         return;
2917 |       }
2918 |     }
2919 |   }
2920 | 
2921 |   function compare(a, b) {
2922 |     // Compare sort index first, then task id.
2923 |     var diff = a.sortIndex - b.sortIndex;
2924 |     return diff !== 0 ? diff : a.id - b.id;
2925 |   }
2926 | 
2927 |   // TODO: Use symbols?
2928 |   var ImmediatePriority = 1;
2929 |   var UserBlockingPriority = 2;
2930 |   var NormalPriority = 3;
2931 |   var LowPriority = 4;
2932 |   var IdlePriority = 5;
2933 | 
2934 |   function markTaskErrored(task, ms) {}
2935 | 
2936 |   /* eslint-disable no-var */
2937 |   // Math.pow(2, 30) - 1
2938 |   // 0b111111111111111111111111111111
2939 | 
2940 |   var maxSigned31BitInt = 1073741823; // Times out immediately
2941 | 
2942 |   var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
2943 | 
2944 |   var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
2945 |   var NORMAL_PRIORITY_TIMEOUT = 5000;
2946 |   var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
2947 | 
2948 |   var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
2949 | 
2950 |   var taskQueue = [];
2951 |   var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
2952 | 
2953 |   var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
2954 |   var currentTask = null;
2955 |   var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrancy.
2956 | 
2957 |   var isPerformingWork = false;
2958 |   var isHostCallbackScheduled = false;
2959 |   var isHostTimeoutScheduled = false;
2960 | 
2961 |   function advanceTimers(currentTime) {
2962 |     // Check for tasks that are no longer delayed and add them to the queue.
2963 |     var timer = peek(timerQueue);
2964 | 
2965 |     while (timer !== null) {
2966 |       if (timer.callback === null) {
2967 |         // Timer was cancelled.
2968 |         pop(timerQueue);
2969 |       } else if (timer.startTime <= currentTime) {
2970 |         // Timer fired. Transfer to the task queue.
2971 |         pop(timerQueue);
2972 |         timer.sortIndex = timer.expirationTime;
2973 |         push(taskQueue, timer);
2974 |       } else {
2975 |         // Remaining timers are pending.
2976 |         return;
2977 |       }
2978 | 
2979 |       timer = peek(timerQueue);
2980 |     }
2981 |   }
2982 | 
2983 |   function handleTimeout(currentTime) {
2984 |     isHostTimeoutScheduled = false;
2985 |     advanceTimers(currentTime);
2986 | 
2987 |     if (!isHostCallbackScheduled) {
2988 |       if (peek(taskQueue) !== null) {
2989 |         isHostCallbackScheduled = true;
2990 |         requestHostCallback(flushWork);
2991 |       } else {
2992 |         var firstTimer = peek(timerQueue);
2993 | 
2994 |         if (firstTimer !== null) {
2995 |           requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
2996 |         }
2997 |       }
2998 |     }
2999 |   }
3000 | 
3001 |   function flushWork(hasTimeRemaining, initialTime) {
3002 |     isHostCallbackScheduled = false;
3003 | 
3004 |     if (isHostTimeoutScheduled) {
3005 |       // We scheduled a timeout but it's no longer needed. Cancel it.
3006 |       isHostTimeoutScheduled = false;
3007 |       cancelHostTimeout();
3008 |     }
3009 | 
3010 |     isPerformingWork = true;
3011 |     var previousPriorityLevel = currentPriorityLevel;
3012 | 
3013 |     try {
3014 |       if (enableProfiling) {
3015 |         try {
3016 |           return workLoop(hasTimeRemaining, initialTime);
3017 |         } catch (error) {
3018 |           if (currentTask !== null) {
3019 |             var currentTime = getCurrentTime();
3020 |             markTaskErrored(currentTask, currentTime);
3021 |             currentTask.isQueued = false;
3022 |           }
3023 | 
3024 |           throw error;
3025 |         }
3026 |       } else {
3027 |         // No catch in prod code path.
3028 |         return workLoop(hasTimeRemaining, initialTime);
3029 |       }
3030 |     } finally {
3031 |       currentTask = null;
3032 |       currentPriorityLevel = previousPriorityLevel;
3033 |       isPerformingWork = false;
3034 |     }
3035 |   }
3036 | 
3037 |   function workLoop(hasTimeRemaining, initialTime) {
3038 |     var currentTime = initialTime;
3039 |     advanceTimers(currentTime);
3040 |     currentTask = peek(taskQueue);
3041 | 
3042 |     while (currentTask !== null && !enableSchedulerDebugging) {
3043 |       if (
3044 |         currentTask.expirationTime > currentTime &&
3045 |         (!hasTimeRemaining || shouldYieldToHost())
3046 |       ) {
3047 |         // This currentTask hasn't expired, and we've reached the deadline.
3048 |         break;
3049 |       }
3050 | 
3051 |       var callback = currentTask.callback;
3052 | 
3053 |       if (typeof callback === "function") {
3054 |         currentTask.callback = null;
3055 |         currentPriorityLevel = currentTask.priorityLevel;
3056 |         var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
3057 | 
3058 |         var continuationCallback = callback(didUserCallbackTimeout);
3059 |         currentTime = getCurrentTime();
3060 | 
3061 |         if (typeof continuationCallback === "function") {
3062 |           currentTask.callback = continuationCallback;
3063 |         } else {
3064 |           if (currentTask === peek(taskQueue)) {
3065 |             pop(taskQueue);
3066 |           }
3067 |         }
3068 | 
3069 |         advanceTimers(currentTime);
3070 |       } else {
3071 |         pop(taskQueue);
3072 |       }
3073 | 
3074 |       currentTask = peek(taskQueue);
3075 |     } // Return whether there's additional work
3076 | 
3077 |     if (currentTask !== null) {
3078 |       return true;
3079 |     } else {
3080 |       var firstTimer = peek(timerQueue);
3081 | 
3082 |       if (firstTimer !== null) {
3083 |         requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
3084 |       }
3085 | 
3086 |       return false;
3087 |     }
3088 |   }
3089 | 
3090 |   function unstable_runWithPriority(priorityLevel, eventHandler) {
3091 |     switch (priorityLevel) {
3092 |       case ImmediatePriority:
3093 |       case UserBlockingPriority:
3094 |       case NormalPriority:
3095 |       case LowPriority:
3096 |       case IdlePriority:
3097 |         break;
3098 | 
3099 |       default:
3100 |         priorityLevel = NormalPriority;
3101 |     }
3102 | 
3103 |     var previousPriorityLevel = currentPriorityLevel;
3104 |     currentPriorityLevel = priorityLevel;
3105 | 
3106 |     try {
3107 |       return eventHandler();
3108 |     } finally {
3109 |       currentPriorityLevel = previousPriorityLevel;
3110 |     }
3111 |   }
3112 | 
3113 |   function unstable_next(eventHandler) {
3114 |     var priorityLevel;
3115 | 
3116 |     switch (currentPriorityLevel) {
3117 |       case ImmediatePriority:
3118 |       case UserBlockingPriority:
3119 |       case NormalPriority:
3120 |         // Shift down to normal priority
3121 |         priorityLevel = NormalPriority;
3122 |         break;
3123 | 
3124 |       default:
3125 |         // Anything lower than normal priority should remain at the current level.
3126 |         priorityLevel = currentPriorityLevel;
3127 |         break;
3128 |     }
3129 | 
3130 |     var previousPriorityLevel = currentPriorityLevel;
3131 |     currentPriorityLevel = priorityLevel;
3132 | 
3133 |     try {
3134 |       return eventHandler();
3135 |     } finally {
3136 |       currentPriorityLevel = previousPriorityLevel;
3137 |     }
3138 |   }
3139 | 
3140 |   function unstable_wrapCallback(callback) {
3141 |     var parentPriorityLevel = currentPriorityLevel;
3142 |     return function () {
3143 |       // This is a fork of runWithPriority, inlined for performance.
3144 |       var previousPriorityLevel = currentPriorityLevel;
3145 |       currentPriorityLevel = parentPriorityLevel;
3146 | 
3147 |       try {
3148 |         return callback.apply(this, arguments);
3149 |       } finally {
3150 |         currentPriorityLevel = previousPriorityLevel;
3151 |       }
3152 |     };
3153 |   }
3154 | 
3155 |   function unstable_scheduleCallback(priorityLevel, callback, options) {
3156 |     var currentTime = getCurrentTime();
3157 |     var startTime;
3158 | 
3159 |     if (typeof options === "object" && options !== null) {
3160 |       var delay = options.delay;
3161 | 
3162 |       if (typeof delay === "number" && delay > 0) {
3163 |         startTime = currentTime + delay;
3164 |       } else {
3165 |         startTime = currentTime;
3166 |       }
3167 |     } else {
3168 |       startTime = currentTime;
3169 |     }
3170 | 
3171 |     var timeout;
3172 | 
3173 |     switch (priorityLevel) {
3174 |       case ImmediatePriority:
3175 |         timeout = IMMEDIATE_PRIORITY_TIMEOUT;
3176 |         break;
3177 | 
3178 |       case UserBlockingPriority:
3179 |         timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
3180 |         break;
3181 | 
3182 |       case IdlePriority:
3183 |         timeout = IDLE_PRIORITY_TIMEOUT;
3184 |         break;
3185 | 
3186 |       case LowPriority:
3187 |         timeout = LOW_PRIORITY_TIMEOUT;
3188 |         break;
3189 | 
3190 |       case NormalPriority:
3191 |       default:
3192 |         timeout = NORMAL_PRIORITY_TIMEOUT;
3193 |         break;
3194 |     }
3195 | 
3196 |     var expirationTime = startTime + timeout;
3197 |     var newTask = {
3198 |       id: taskIdCounter++,
3199 |       callback: callback,
3200 |       priorityLevel: priorityLevel,
3201 |       startTime: startTime,
3202 |       expirationTime: expirationTime,
3203 |       sortIndex: -1,
3204 |     };
3205 | 
3206 |     if (startTime > currentTime) {
3207 |       // This is a delayed task.
3208 |       newTask.sortIndex = startTime;
3209 |       push(timerQueue, newTask);
3210 | 
3211 |       if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
3212 |         // All tasks are delayed, and this is the task with the earliest delay.
3213 |         if (isHostTimeoutScheduled) {
3214 |           // Cancel an existing timeout.
3215 |           cancelHostTimeout();
3216 |         } else {
3217 |           isHostTimeoutScheduled = true;
3218 |         } // Schedule a timeout.
3219 | 
3220 |         requestHostTimeout(handleTimeout, startTime - currentTime);
3221 |       }
3222 |     } else {
3223 |       newTask.sortIndex = expirationTime;
3224 |       push(taskQueue, newTask);
3225 |       // wait until the next time we yield.
3226 | 
3227 |       if (!isHostCallbackScheduled && !isPerformingWork) {
3228 |         isHostCallbackScheduled = true;
3229 |         requestHostCallback(flushWork);
3230 |       }
3231 |     }
3232 | 
3233 |     return newTask;
3234 |   }
3235 | 
3236 |   function unstable_pauseExecution() {}
3237 | 
3238 |   function unstable_continueExecution() {
3239 |     if (!isHostCallbackScheduled && !isPerformingWork) {
3240 |       isHostCallbackScheduled = true;
3241 |       requestHostCallback(flushWork);
3242 |     }
3243 |   }
3244 | 
3245 |   function unstable_getFirstCallbackNode() {
3246 |     return peek(taskQueue);
3247 |   }
3248 | 
3249 |   function unstable_cancelCallback(task) {
3250 |     // remove from the queue because you can't remove arbitrary nodes from an
3251 |     // array based heap, only the first one.)
3252 | 
3253 |     task.callback = null;
3254 |   }
3255 | 
3256 |   function unstable_getCurrentPriorityLevel() {
3257 |     return currentPriorityLevel;
3258 |   }
3259 | 
3260 |   var unstable_requestPaint = requestPaint;
3261 |   var unstable_Profiling = null;
3262 | 
3263 |   var Scheduler = /*#__PURE__*/ Object.freeze({
3264 |     __proto__: null,
3265 |     unstable_ImmediatePriority: ImmediatePriority,
3266 |     unstable_UserBlockingPriority: UserBlockingPriority,
3267 |     unstable_NormalPriority: NormalPriority,
3268 |     unstable_IdlePriority: IdlePriority,
3269 |     unstable_LowPriority: LowPriority,
3270 |     unstable_runWithPriority: unstable_runWithPriority,
3271 |     unstable_next: unstable_next,
3272 |     unstable_scheduleCallback: unstable_scheduleCallback,
3273 |     unstable_cancelCallback: unstable_cancelCallback,
3274 |     unstable_wrapCallback: unstable_wrapCallback,
3275 |     unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
3276 |     get unstable_shouldYield() {
3277 |       return shouldYieldToHost;
3278 |     },
3279 |     unstable_requestPaint: unstable_requestPaint,
3280 |     unstable_continueExecution: unstable_continueExecution,
3281 |     unstable_pauseExecution: unstable_pauseExecution,
3282 |     unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
3283 |     get unstable_now() {
3284 |       return getCurrentTime;
3285 |     },
3286 |     get unstable_forceFrameRate() {
3287 |       return forceFrameRate;
3288 |     },
3289 |     unstable_Profiling: unstable_Profiling,
3290 |   });
3291 | 
3292 |   var DEFAULT_THREAD_ID = 0; // Counters used to generate unique IDs.
3293 | 
3294 |   var interactionIDCounter = 0;
3295 |   var threadIDCounter = 0; // Set of currently traced interactions.
3296 |   // Interactions "stack"–
3297 |   // Meaning that newly traced interactions are appended to the previously active set.
3298 |   // When an interaction goes out of scope, the previous set (if any) is restored.
3299 | 
3300 |   var interactionsRef = null; // Listener(s) to notify when interactions begin and end.
3301 | 
3302 |   var subscriberRef = null;
3303 | 
3304 |   {
3305 |     interactionsRef = {
3306 |       current: new Set(),
3307 |     };
3308 |     subscriberRef = {
3309 |       current: null,
3310 |     };
3311 |   }
3312 |   function unstable_clear(callback) {
3313 |     var prevInteractions = interactionsRef.current;
3314 |     interactionsRef.current = new Set();
3315 | 
3316 |     try {
3317 |       return callback();
3318 |     } finally {
3319 |       interactionsRef.current = prevInteractions;
3320 |     }
3321 |   }
3322 |   function unstable_getCurrent() {
3323 |     {
3324 |       return interactionsRef.current;
3325 |     }
3326 |   }
3327 |   function unstable_getThreadID() {
3328 |     return ++threadIDCounter;
3329 |   }
3330 |   function unstable_trace(name, timestamp, callback) {
3331 |     var threadID =
3332 |       arguments.length > 3 && arguments[3] !== undefined
3333 |         ? arguments[3]
3334 |         : DEFAULT_THREAD_ID;
3335 | 
3336 |     var interaction = {
3337 |       __count: 1,
3338 |       id: interactionIDCounter++,
3339 |       name: name,
3340 |       timestamp: timestamp,
3341 |     };
3342 |     var prevInteractions = interactionsRef.current; // Traced interactions should stack/accumulate.
3343 |     // To do that, clone the current interactions.
3344 |     // The previous set will be restored upon completion.
3345 | 
3346 |     var interactions = new Set(prevInteractions);
3347 |     interactions.add(interaction);
3348 |     interactionsRef.current = interactions;
3349 |     var subscriber = subscriberRef.current;
3350 |     var returnValue;
3351 | 
3352 |     try {
3353 |       if (subscriber !== null) {
3354 |         subscriber.onInteractionTraced(interaction);
3355 |       }
3356 |     } finally {
3357 |       try {
3358 |         if (subscriber !== null) {
3359 |           subscriber.onWorkStarted(interactions, threadID);
3360 |         }
3361 |       } finally {
3362 |         try {
3363 |           returnValue = callback();
3364 |         } finally {
3365 |           interactionsRef.current = prevInteractions;
3366 | 
3367 |           try {
3368 |             if (subscriber !== null) {
3369 |               subscriber.onWorkStopped(interactions, threadID);
3370 |             }
3371 |           } finally {
3372 |             interaction.__count--; // If no async work was scheduled for this interaction,
3373 |             // Notify subscribers that it's completed.
3374 | 
3375 |             if (subscriber !== null && interaction.__count === 0) {
3376 |               subscriber.onInteractionScheduledWorkCompleted(interaction);
3377 |             }
3378 |           }
3379 |         }
3380 |       }
3381 |     }
3382 | 
3383 |     return returnValue;
3384 |   }
3385 |   function unstable_wrap(callback) {
3386 |     var threadID =
3387 |       arguments.length > 1 && arguments[1] !== undefined
3388 |         ? arguments[1]
3389 |         : DEFAULT_THREAD_ID;
3390 | 
3391 |     var wrappedInteractions = interactionsRef.current;
3392 |     var subscriber = subscriberRef.current;
3393 | 
3394 |     if (subscriber !== null) {
3395 |       subscriber.onWorkScheduled(wrappedInteractions, threadID);
3396 |     } // Update the pending async work count for the current interactions.
3397 |     // Update after calling subscribers in case of error.
3398 | 
3399 |     wrappedInteractions.forEach(function (interaction) {
3400 |       interaction.__count++;
3401 |     });
3402 |     var hasRun = false;
3403 | 
3404 |     function wrapped() {
3405 |       var prevInteractions = interactionsRef.current;
3406 |       interactionsRef.current = wrappedInteractions;
3407 |       subscriber = subscriberRef.current;
3408 | 
3409 |       try {
3410 |         var returnValue;
3411 | 
3412 |         try {
3413 |           if (subscriber !== null) {
3414 |             subscriber.onWorkStarted(wrappedInteractions, threadID);
3415 |           }
3416 |         } finally {
3417 |           try {
3418 |             returnValue = callback.apply(undefined, arguments);
3419 |           } finally {
3420 |             interactionsRef.current = prevInteractions;
3421 | 
3422 |             if (subscriber !== null) {
3423 |               subscriber.onWorkStopped(wrappedInteractions, threadID);
3424 |             }
3425 |           }
3426 |         }
3427 | 
3428 |         return returnValue;
3429 |       } finally {
3430 |         if (!hasRun) {
3431 |           // We only expect a wrapped function to be executed once,
3432 |           // But in the event that it's executed more than once–
3433 |           // Only decrement the outstanding interaction counts once.
3434 |           hasRun = true; // Update pending async counts for all wrapped interactions.
3435 |           // If this was the last scheduled async work for any of them,
3436 |           // Mark them as completed.
3437 | 
3438 |           wrappedInteractions.forEach(function (interaction) {
3439 |             interaction.__count--;
3440 | 
3441 |             if (subscriber !== null && interaction.__count === 0) {
3442 |               subscriber.onInteractionScheduledWorkCompleted(interaction);
3443 |             }
3444 |           });
3445 |         }
3446 |       }
3447 |     }
3448 | 
3449 |     wrapped.cancel = function cancel() {
3450 |       subscriber = subscriberRef.current;
3451 | 
3452 |       try {
3453 |         if (subscriber !== null) {
3454 |           subscriber.onWorkCanceled(wrappedInteractions, threadID);
3455 |         }
3456 |       } finally {
3457 |         // Update pending async counts for all wrapped interactions.
3458 |         // If this was the last scheduled async work for any of them,
3459 |         // Mark them as completed.
3460 |         wrappedInteractions.forEach(function (interaction) {
3461 |           interaction.__count--;
3462 | 
3463 |           if (subscriber && interaction.__count === 0) {
3464 |             subscriber.onInteractionScheduledWorkCompleted(interaction);
3465 |           }
3466 |         });
3467 |       }
3468 |     };
3469 | 
3470 |     return wrapped;
3471 |   }
3472 | 
3473 |   var subscribers = null;
3474 | 
3475 |   {
3476 |     subscribers = new Set();
3477 |   }
3478 | 
3479 |   function unstable_subscribe(subscriber) {
3480 |     {
3481 |       subscribers.add(subscriber);
3482 | 
3483 |       if (subscribers.size === 1) {
3484 |         subscriberRef.current = {
3485 |           onInteractionScheduledWorkCompleted:
3486 |             onInteractionScheduledWorkCompleted,
3487 |           onInteractionTraced: onInteractionTraced,
3488 |           onWorkCanceled: onWorkCanceled,
3489 |           onWorkScheduled: onWorkScheduled,
3490 |           onWorkStarted: onWorkStarted,
3491 |           onWorkStopped: onWorkStopped,
3492 |         };
3493 |       }
3494 |     }
3495 |   }
3496 |   function unstable_unsubscribe(subscriber) {
3497 |     {
3498 |       subscribers.delete(subscriber);
3499 | 
3500 |       if (subscribers.size === 0) {
3501 |         subscriberRef.current = null;
3502 |       }
3503 |     }
3504 |   }
3505 | 
3506 |   function onInteractionTraced(interaction) {
3507 |     var didCatchError = false;
3508 |     var caughtError = null;
3509 |     subscribers.forEach(function (subscriber) {
3510 |       try {
3511 |         subscriber.onInteractionTraced(interaction);
3512 |       } catch (error) {
3513 |         if (!didCatchError) {
3514 |           didCatchError = true;
3515 |           caughtError = error;
3516 |         }
3517 |       }
3518 |     });
3519 | 
3520 |     if (didCatchError) {
3521 |       throw caughtError;
3522 |     }
3523 |   }
3524 | 
3525 |   function onInteractionScheduledWorkCompleted(interaction) {
3526 |     var didCatchError = false;
3527 |     var caughtError = null;
3528 |     subscribers.forEach(function (subscriber) {
3529 |       try {
3530 |         subscriber.onInteractionScheduledWorkCompleted(interaction);
3531 |       } catch (error) {
3532 |         if (!didCatchError) {
3533 |           didCatchError = true;
3534 |           caughtError = error;
3535 |         }
3536 |       }
3537 |     });
3538 | 
3539 |     if (didCatchError) {
3540 |       throw caughtError;
3541 |     }
3542 |   }
3543 | 
3544 |   function onWorkScheduled(interactions, threadID) {
3545 |     var didCatchError = false;
3546 |     var caughtError = null;
3547 |     subscribers.forEach(function (subscriber) {
3548 |       try {
3549 |         subscriber.onWorkScheduled(interactions, threadID);
3550 |       } catch (error) {
3551 |         if (!didCatchError) {
3552 |           didCatchError = true;
3553 |           caughtError = error;
3554 |         }
3555 |       }
3556 |     });
3557 | 
3558 |     if (didCatchError) {
3559 |       throw caughtError;
3560 |     }
3561 |   }
3562 | 
3563 |   function onWorkStarted(interactions, threadID) {
3564 |     var didCatchError = false;
3565 |     var caughtError = null;
3566 |     subscribers.forEach(function (subscriber) {
3567 |       try {
3568 |         subscriber.onWorkStarted(interactions, threadID);
3569 |       } catch (error) {
3570 |         if (!didCatchError) {
3571 |           didCatchError = true;
3572 |           caughtError = error;
3573 |         }
3574 |       }
3575 |     });
3576 | 
3577 |     if (didCatchError) {
3578 |       throw caughtError;
3579 |     }
3580 |   }
3581 | 
3582 |   function onWorkStopped(interactions, threadID) {
3583 |     var didCatchError = false;
3584 |     var caughtError = null;
3585 |     subscribers.forEach(function (subscriber) {
3586 |       try {
3587 |         subscriber.onWorkStopped(interactions, threadID);
3588 |       } catch (error) {
3589 |         if (!didCatchError) {
3590 |           didCatchError = true;
3591 |           caughtError = error;
3592 |         }
3593 |       }
3594 |     });
3595 | 
3596 |     if (didCatchError) {
3597 |       throw caughtError;
3598 |     }
3599 |   }
3600 | 
3601 |   function onWorkCanceled(interactions, threadID) {
3602 |     var didCatchError = false;
3603 |     var caughtError = null;
3604 |     subscribers.forEach(function (subscriber) {
3605 |       try {
3606 |         subscriber.onWorkCanceled(interactions, threadID);
3607 |       } catch (error) {
3608 |         if (!didCatchError) {
3609 |           didCatchError = true;
3610 |           caughtError = error;
3611 |         }
3612 |       }
3613 |     });
3614 | 
3615 |     if (didCatchError) {
3616 |       throw caughtError;
3617 |     }
3618 |   }
3619 | 
3620 |   var SchedulerTracing = /*#__PURE__*/ Object.freeze({
3621 |     __proto__: null,
3622 |     get __interactionsRef() {
3623 |       return interactionsRef;
3624 |     },
3625 |     get __subscriberRef() {
3626 |       return subscriberRef;
3627 |     },
3628 |     unstable_clear: unstable_clear,
3629 |     unstable_getCurrent: unstable_getCurrent,
3630 |     unstable_getThreadID: unstable_getThreadID,
3631 |     unstable_trace: unstable_trace,
3632 |     unstable_wrap: unstable_wrap,
3633 |     unstable_subscribe: unstable_subscribe,
3634 |     unstable_unsubscribe: unstable_unsubscribe,
3635 |   });
3636 | 
3637 |   var ReactSharedInternals$1 = {
3638 |     ReactCurrentDispatcher: ReactCurrentDispatcher,
3639 |     ReactCurrentOwner: ReactCurrentOwner,
3640 |     IsSomeRendererActing: IsSomeRendererActing,
3641 |     ReactCurrentBatchConfig: ReactCurrentBatchConfig,
3642 |     // Used by renderers to avoid bundling object-assign twice in UMD bundles:
3643 |     assign: assign,
3644 |     // Re-export the schedule API(s) for UMD bundles.
3645 |     // This avoids introducing a dependency on a new UMD global in a minor update,
3646 |     // Since that would be a breaking change (e.g. for all existing CodeSandboxes).
3647 |     // This re-export is only required for UMD bundles;
3648 |     // CJS bundles use the shared NPM package.
3649 |     Scheduler: Scheduler,
3650 |     SchedulerTracing: SchedulerTracing,
3651 |   };
3652 | 
3653 |   {
3654 |     ReactSharedInternals$1.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
3655 |   }
3656 | 
3657 |   {
3658 |     try {
3659 |       var frozenObject = Object.freeze({});
3660 |       /* eslint-disable no-new */
3661 | 
3662 |       new Map([[frozenObject, null]]);
3663 |       new Set([frozenObject]);
3664 |       /* eslint-enable no-new */
3665 |     } catch (e) {}
3666 |   }
3667 | 
3668 |   var createElement$1 = createElementWithValidation;
3669 |   var cloneElement$1 = cloneElementWithValidation;
3670 |   var createFactory = createFactoryWithValidation;
3671 |   var Children = {
3672 |     map: mapChildren,
3673 |     forEach: forEachChildren,
3674 |     count: countChildren,
3675 |     toArray: toArray,
3676 |     only: onlyChild,
3677 |   };
3678 | 
3679 |   exports.Children = Children;
3680 |   exports.Component = Component;
3681 |   exports.PureComponent = PureComponent;
3682 |   exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =
3683 |     ReactSharedInternals$1;
3684 |   exports.cloneElement = cloneElement$1;
3685 |   exports.createContext = createContext;
3686 |   exports.createElement = createElement$1;
3687 |   exports.createFactory = createFactory;
3688 |   exports.createRef = createRef;
3689 |   exports.forwardRef = forwardRef;
3690 |   exports.isValidElement = isValidElement;
3691 |   exports.lazy = lazy;
3692 |   exports.memo = memo;
3693 |   exports.useCallback = useCallback;
3694 |   exports.useContext = useContext;
3695 |   exports.useDebugValue = useDebugValue;
3696 |   exports.useEffect = useEffect;
3697 |   exports.useImperativeHandle = useImperativeHandle;
3698 |   exports.useLayoutEffect = useLayoutEffect;
3699 |   exports.useMemo = useMemo;
3700 |   exports.useReducer = useReducer;
3701 |   exports.useRef = useRef;
3702 |   exports.useState = useState;
3703 |   exports.version = ReactVersion;
3704 | });
3705 |

--------------------------------------------------------------------------------