From f431e04bdaba1b6b6bf23c193f556af765a91371 Mon Sep 17 00:00:00 2001 From: Boshen Date: Sat, 14 Sep 2024 15:02:15 +0800 Subject: [PATCH] feat(parser,codegen): parse and print leading comments --- crates/oxc_ast/src/lib.rs | 2 +- crates/oxc_ast/src/trivia.rs | 52 +- crates/oxc_codegen/src/gen.rs | 949 +- crates/oxc_codegen/src/lib.rs | 58 +- crates/oxc_parser/examples/parser.rs | 2 +- crates/oxc_parser/src/lexer/mod.rs | 2 + crates/oxc_parser/src/lexer/trivia_builder.rs | 65 +- crates/oxc_parser/src/lexer/unicode.rs | 1 + crates/oxc_parser/src/lexer/whitespace.rs | 1 + tasks/coverage/codegen_sourcemap.snap | 9236 ++++++++--------- tasks/transform_conformance/babel.snap.md | 48 +- tasks/transform_conformance/src/test_case.rs | 7 +- 12 files changed, 5278 insertions(+), 5145 deletions(-) diff --git a/crates/oxc_ast/src/lib.rs b/crates/oxc_ast/src/lib.rs index 84fe417b50ae2..006fa94352287 100644 --- a/crates/oxc_ast/src/lib.rs +++ b/crates/oxc_ast/src/lib.rs @@ -61,7 +61,7 @@ pub use crate::{ ast_builder::AstBuilder, ast_builder_impl::NONE, ast_kind::{AstKind, AstType}, - trivia::{Comment, CommentKind, SortedComments, Trivias}, + trivia::{Comment, CommentKind, CommentPosition, SortedComments, Trivias}, visit::{Visit, VisitMut}, }; diff --git a/crates/oxc_ast/src/trivia.rs b/crates/oxc_ast/src/trivia.rs index 721d31d32d2bf..a436922b1c652 100644 --- a/crates/oxc_ast/src/trivia.rs +++ b/crates/oxc_ast/src/trivia.rs @@ -8,19 +8,39 @@ use std::{ use oxc_span::Span; +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub enum CommentPosition { + Leading, + Trailing, + Dangling, +} + /// Single or multiline comment #[derive(Debug, Clone, Copy)] pub struct Comment { pub kind: CommentKind, /// The span of the comment text (without leading/trailing delimiters). pub span: Span, + + pub position: CommentPosition, + pub preceded_by_newline: Option, + pub followed_by_newline: Option, + + pub attached_to: u32, } impl Comment { #[inline] pub fn new(start: u32, end: u32, kind: CommentKind) -> Self { let span = Span::new(start, end); - Self { kind, span } + Self { + kind, + span, + position: CommentPosition::Dangling, + preceded_by_newline: None, + followed_by_newline: None, + attached_to: 0, + } } pub fn real_span(&self) -> Span { @@ -40,6 +60,26 @@ impl Comment { CommentKind::SingleLine | CommentKind::MultiLine => self.span.start - 2, } } + + #[inline] + pub fn is_single_line(self) -> bool { + self.kind == CommentKind::SingleLine + } + + #[inline] + pub fn is_multi_line(self) -> bool { + self.kind == CommentKind::MultiLine + } + + #[inline] + pub fn is_leading(&self) -> bool { + self.position == CommentPosition::Leading + } + + #[inline] + pub fn is_trailing(&self) -> bool { + self.position == CommentPosition::Trailing + } } #[derive(Debug, Clone, Copy, Eq, PartialEq)] @@ -192,11 +232,11 @@ mod test { #[test] fn test_comments_range() { let comments: SortedComments = vec![ - Comment { span: Span::new(0, 4), kind: CommentKind::SingleLine }, - Comment { span: Span::new(5, 9), kind: CommentKind::SingleLine }, - Comment { span: Span::new(10, 13), kind: CommentKind::SingleLine }, - Comment { span: Span::new(14, 17), kind: CommentKind::SingleLine }, - Comment { span: Span::new(18, 23), kind: CommentKind::SingleLine }, + Comment::new(0, 4, CommentKind::SingleLine), + Comment::new(5, 9, CommentKind::SingleLine), + Comment::new(10, 13, CommentKind::SingleLine), + Comment::new(14, 17, CommentKind::SingleLine), + Comment::new(18, 23, CommentKind::SingleLine), ] .into_boxed_slice(); let full_len = comments.len(); diff --git a/crates/oxc_codegen/src/gen.rs b/crates/oxc_codegen/src/gen.rs index 453ec8f91b15b..5faacc76334b0 100644 --- a/crates/oxc_codegen/src/gen.rs +++ b/crates/oxc_codegen/src/gen.rs @@ -19,24 +19,43 @@ use crate::{ pub trait Gen: GetSpan { fn gen(&self, p: &mut Codegen, ctx: Context); + + fn print(&self, p: &mut Codegen, ctx: Context) { + p.print_leading_comments(self.span().start); + self.gen(p, ctx); + // p.print_trailing_comments(self.span().end); + } } pub trait GenExpr: GetSpan { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context); + + fn print_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { + p.print_leading_comments(self.span().start); + self.gen_expr(p, precedence, ctx); + // p.print_trailing_comments(self.span().end); + } } impl<'a> Gen for Program<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { if let Some(hashbang) = &self.hashbang { - hashbang.gen(p, ctx); + hashbang.print(p, ctx); } for directive in &self.directives { - directive.gen(p, ctx); + directive.print(p, ctx); } for stmt in &self.body { - stmt.gen(p, ctx); + stmt.print(p, ctx); p.print_semicolon_if_needed(); } + p.print_leading_comments(self.span.end); + // if p.comments.len() != 0 { + // while let Some(comment) = p.comments.next() { + // println!("*****{}*****", comment.real_span().source_text(p.source_text.unwrap())); + // } + // panic!("{:?}", p.source_text); + // } } } @@ -65,70 +84,70 @@ impl<'a> Gen for Directive<'a> { impl<'a> Gen for Statement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::BlockStatement(stmt) => stmt.gen(p, ctx), - Self::BreakStatement(stmt) => stmt.gen(p, ctx), - Self::ContinueStatement(stmt) => stmt.gen(p, ctx), - Self::DebuggerStatement(stmt) => stmt.gen(p, ctx), - Self::DoWhileStatement(stmt) => stmt.gen(p, ctx), - Self::EmptyStatement(stmt) => stmt.gen(p, ctx), - Self::ExpressionStatement(stmt) => stmt.gen(p, ctx), - Self::ForInStatement(stmt) => stmt.gen(p, ctx), - Self::ForOfStatement(stmt) => stmt.gen(p, ctx), - Self::ForStatement(stmt) => stmt.gen(p, ctx), - Self::IfStatement(stmt) => stmt.gen(p, ctx), - Self::LabeledStatement(stmt) => stmt.gen(p, ctx), - Self::ReturnStatement(stmt) => stmt.gen(p, ctx), - Self::SwitchStatement(stmt) => stmt.gen(p, ctx), - Self::ThrowStatement(stmt) => stmt.gen(p, ctx), - Self::TryStatement(stmt) => stmt.gen(p, ctx), - Self::WhileStatement(stmt) => stmt.gen(p, ctx), - Self::WithStatement(stmt) => stmt.gen(p, ctx), - - Self::ImportDeclaration(decl) => decl.gen(p, ctx), - Self::ExportAllDeclaration(decl) => decl.gen(p, ctx), - Self::ExportDefaultDeclaration(decl) => decl.gen(p, ctx), - Self::ExportNamedDeclaration(decl) => decl.gen(p, ctx), - Self::TSExportAssignment(decl) => decl.gen(p, ctx), - Self::TSNamespaceExportDeclaration(decl) => decl.gen(p, ctx), + Self::BlockStatement(stmt) => stmt.print(p, ctx), + Self::BreakStatement(stmt) => stmt.print(p, ctx), + Self::ContinueStatement(stmt) => stmt.print(p, ctx), + Self::DebuggerStatement(stmt) => stmt.print(p, ctx), + Self::DoWhileStatement(stmt) => stmt.print(p, ctx), + Self::EmptyStatement(stmt) => stmt.print(p, ctx), + Self::ExpressionStatement(stmt) => stmt.print(p, ctx), + Self::ForInStatement(stmt) => stmt.print(p, ctx), + Self::ForOfStatement(stmt) => stmt.print(p, ctx), + Self::ForStatement(stmt) => stmt.print(p, ctx), + Self::IfStatement(stmt) => stmt.print(p, ctx), + Self::LabeledStatement(stmt) => stmt.print(p, ctx), + Self::ReturnStatement(stmt) => stmt.print(p, ctx), + Self::SwitchStatement(stmt) => stmt.print(p, ctx), + Self::ThrowStatement(stmt) => stmt.print(p, ctx), + Self::TryStatement(stmt) => stmt.print(p, ctx), + Self::WhileStatement(stmt) => stmt.print(p, ctx), + Self::WithStatement(stmt) => stmt.print(p, ctx), + + Self::ImportDeclaration(decl) => decl.print(p, ctx), + Self::ExportAllDeclaration(decl) => decl.print(p, ctx), + Self::ExportDefaultDeclaration(decl) => decl.print(p, ctx), + Self::ExportNamedDeclaration(decl) => decl.print(p, ctx), + Self::TSExportAssignment(decl) => decl.print(p, ctx), + Self::TSNamespaceExportDeclaration(decl) => decl.print(p, ctx), Self::VariableDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_semicolon_after_statement(); } Self::FunctionDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_soft_newline(); } Self::ClassDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_soft_newline(); } Self::TSModuleDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_soft_newline(); } Self::TSTypeAliasDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_semicolon_after_statement(); } Self::TSInterfaceDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_soft_newline(); } Self::TSEnumDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_soft_newline(); } Self::TSImportEqualsDeclaration(decl) => { p.print_indent(); - decl.gen(p, ctx); + decl.print(p, ctx); p.print_semicolon_after_statement(); } } @@ -145,6 +164,7 @@ impl<'a> Gen for ExpressionStatement<'a> { p.print_semicolon(); } else { p.print_semicolon_after_statement(); + // p.print_trailing_comments(self.span.end); } } } @@ -177,7 +197,7 @@ fn print_if(if_stmt: &IfStatement<'_>, p: &mut Codegen, ctx: Context) { stmt if wrap_to_avoid_ambiguous_else(stmt) => { p.print_soft_space(); p.print_block_start(stmt.span().start); - stmt.gen(p, ctx); + stmt.print(p, ctx); p.needs_semicolon = false; p.print_block_end(stmt.span().end); if if_stmt.alternate.is_some() { @@ -247,7 +267,7 @@ impl<'a> Gen for ForStatement<'a> { p.print_char(b'('); if let Some(init) = &self.init { - init.gen(p, Context::FORBID_IN); + init.print(p, Context::FORBID_IN); } p.print_semicolon(); @@ -276,7 +296,7 @@ impl<'a> Gen for ForInStatement<'a> { p.print_str("for"); p.print_soft_space(); p.print_char(b'('); - self.left.gen(p, Context::empty().and_forbid_in(false)); + self.left.print(p, Context::empty().and_forbid_in(false)); p.print_soft_space(); p.print_space_before_identifier(); p.print_str("in"); @@ -297,11 +317,11 @@ impl<'a> Gen for ForOfStatement<'a> { p.print_str(" await"); } p.print_char(b'('); - self.left.gen(p, ctx); + self.left.print(p, ctx); p.print_soft_space(); p.print_space_before_identifier(); p.print_str("of "); - self.right.gen_expr(p, Precedence::Comma, Context::empty()); + self.right.print_expr(p, Precedence::Comma, Context::empty()); p.print_char(b')'); p.print_body(&self.body, false, ctx); } @@ -311,9 +331,9 @@ impl<'a> Gen for ForStatementInit<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { match_expression!(ForStatementInit) => { - self.to_expression().gen_expr(p, Precedence::Lowest, ctx); + self.to_expression().print_expr(p, Precedence::Lowest, ctx); } - Self::VariableDeclaration(var) => var.gen(p, ctx), + Self::VariableDeclaration(var) => var.print(p, ctx), } } } @@ -321,13 +341,13 @@ impl<'a> Gen for ForStatementInit<'a> { impl<'a> Gen for ForStatementLeft<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - ForStatementLeft::VariableDeclaration(var) => var.gen(p, ctx), + ForStatementLeft::VariableDeclaration(var) => var.print(p, ctx), ForStatementLeft::AssignmentTargetIdentifier(identifier) => { let wrap = identifier.name == "async"; - p.wrap(wrap, |p| self.to_assignment_target().gen(p, ctx)); + p.wrap(wrap, |p| self.to_assignment_target().print(p, ctx)); } match_assignment_target!(ForStatementLeft) => { - p.wrap(false, |p| self.to_assignment_target().gen(p, ctx)); + p.wrap(false, |p| self.to_assignment_target().print(p, ctx)); } } } @@ -357,7 +377,7 @@ impl<'a> Gen for DoWhileStatement<'a> { } else { p.print_soft_newline(); p.indent(); - self.body.gen(p, ctx); + self.body.print(p, ctx); p.print_semicolon_if_needed(); p.dedent(); p.print_indent(); @@ -387,7 +407,7 @@ impl<'a> Gen for ContinueStatement<'a> { p.print_str("continue"); if let Some(label) = &self.label { p.print_hard_space(); - label.gen(p, ctx); + label.print(p, ctx); } p.print_semicolon_after_statement(); } @@ -400,7 +420,7 @@ impl<'a> Gen for BreakStatement<'a> { p.print_str("break"); if let Some(label) = &self.label { p.print_hard_space(); - label.gen(p, ctx); + label.print(p, ctx); } p.print_semicolon_after_statement(); } @@ -419,7 +439,7 @@ impl<'a> Gen for SwitchStatement<'a> { p.print_curly_braces(self.span, self.cases.is_empty(), |p| { for case in &self.cases { p.add_source_mapping(case.span.start); - case.gen(p, ctx); + case.print(p, ctx); } }); p.print_soft_newline(); @@ -440,16 +460,16 @@ impl<'a> Gen for SwitchCase<'a> { } p.print_colon(); - if self.consequent.len() == 1 { - p.print_body(&self.consequent[0], false, ctx); - return; - } + // if self.consequent.len() == 1 { + // p.print_body(&self.consequent[0], false, ctx); + // return; + // } p.print_soft_newline(); p.indent(); for item in &self.consequent { p.print_semicolon_if_needed(); - item.gen(p, ctx); + item.print(p, ctx); } p.dedent(); } @@ -475,7 +495,7 @@ impl<'a> Gen for LabeledStatement<'a> { p.print_indent(); } p.print_space_before_identifier(); - self.label.gen(p, ctx); + self.label.print(p, ctx); p.print_colon(); p.print_body(&self.body, false, ctx); } @@ -495,7 +515,7 @@ impl<'a> Gen for TryStatement<'a> { if let Some(param) = &handler.param { p.print_soft_space(); p.print_str("("); - param.pattern.gen(p, ctx); + param.pattern.print(p, ctx); p.print_str(")"); } p.print_soft_space(); @@ -581,12 +601,12 @@ impl<'a> Gen for VariableDeclaration<'a> { impl<'a> Gen for VariableDeclarator<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.id.gen(p, ctx); + self.id.print(p, ctx); if let Some(init) = &self.init { p.print_soft_space(); p.print_equal(); p.print_soft_space(); - init.gen_expr(p, Precedence::Comma, ctx); + init.print_expr(p, Precedence::Comma, ctx); } } } @@ -595,6 +615,7 @@ impl<'a> Gen for Function<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { let n = p.code_len(); let wrap = self.is_expression() && (p.start_of_stmt == n || p.start_of_default_export == n); + p.gen_comments(self.span.start); p.wrap(wrap, |p| { p.print_space_before_identifier(); @@ -612,28 +633,28 @@ impl<'a> Gen for Function<'a> { } if let Some(id) = &self.id { p.print_space_before_identifier(); - id.gen(p, ctx); + id.print(p, ctx); } if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_char(b'('); if let Some(this_param) = &self.this_param { - this_param.gen(p, ctx); + this_param.print(p, ctx); if !self.params.is_empty() || self.params.rest.is_some() { p.print_str(","); } p.print_soft_space(); } - self.params.gen(p, ctx); + self.params.print(p, ctx); p.print_char(b')'); if let Some(return_type) = &self.return_type { p.print_str(": "); - return_type.gen(p, ctx); + return_type.print(p, ctx); } if let Some(body) = &self.body { p.print_soft_space(); - body.gen(p, ctx); + body.print(p, ctx); } else { p.print_semicolon(); } @@ -645,11 +666,11 @@ impl<'a> Gen for FunctionBody<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_curly_braces(self.span, self.is_empty(), |p| { for directive in &self.directives { - directive.gen(p, ctx); + directive.print(p, ctx); } for stmt in &self.statements { p.print_semicolon_if_needed(); - stmt.gen(p, ctx); + stmt.print(p, ctx); } }); p.needs_semicolon = false; @@ -659,7 +680,7 @@ impl<'a> Gen for FunctionBody<'a> { impl<'a> Gen for FormalParameter<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { for decorator in &self.decorators { - decorator.gen(p, ctx); + decorator.print(p, ctx); p.print_hard_space(); } if let Some(accessibility) = self.accessibility { @@ -669,7 +690,7 @@ impl<'a> Gen for FormalParameter<'a> { if self.readonly { p.print_str("readonly "); } - self.pattern.gen(p, ctx); + self.pattern.print(p, ctx); } } @@ -681,7 +702,7 @@ impl<'a> Gen for FormalParameters<'a> { p.print_comma(); p.print_soft_space(); } - rest.gen(p, ctx); + rest.print(p, ctx); } } } @@ -705,7 +726,7 @@ impl<'a> Gen for ImportDeclaration<'a> { p.print_char(b'"'); if let Some(with_clause) = &self.with_clause { p.print_hard_space(); - with_clause.gen(p, ctx); + with_clause.print(p, ctx); } p.print_semicolon_after_statement(); return; @@ -723,7 +744,7 @@ impl<'a> Gen for ImportDeclaration<'a> { p.print_comma(); p.print_soft_space(); } - spec.local.gen(p, ctx); + spec.local.print(p, ctx); } ImportDeclarationSpecifier::ImportNamespaceSpecifier(spec) => { if in_block { @@ -735,7 +756,7 @@ impl<'a> Gen for ImportDeclaration<'a> { p.print_soft_space(); } p.print_str("* as "); - spec.local.gen(p, ctx); + spec.local.print(p, ctx); } ImportDeclarationSpecifier::ImportSpecifier(spec) => { if in_block { @@ -757,15 +778,15 @@ impl<'a> Gen for ImportDeclaration<'a> { let imported_name = match &spec.imported { ModuleExportName::IdentifierName(identifier) => { - identifier.gen(p, ctx); + identifier.print(p, ctx); identifier.name.as_str() } ModuleExportName::IdentifierReference(identifier) => { - identifier.gen(p, ctx); + identifier.print(p, ctx); identifier.name.as_str() } ModuleExportName::StringLiteral(literal) => { - literal.gen(p, ctx); + literal.print(p, ctx); literal.value.as_str() } }; @@ -774,7 +795,7 @@ impl<'a> Gen for ImportDeclaration<'a> { if imported_name != local_name { p.print_str(" as "); - spec.local.gen(p, ctx); + spec.local.print(p, ctx); } } } @@ -785,10 +806,10 @@ impl<'a> Gen for ImportDeclaration<'a> { } p.print_str(" from "); } - self.source.gen(p, ctx); + self.source.print(p, ctx); if let Some(with_clause) = &self.with_clause { p.print_hard_space(); - with_clause.gen(p, ctx); + with_clause.print(p, ctx); } p.add_source_mapping(self.span.end); p.print_semicolon_after_statement(); @@ -798,7 +819,7 @@ impl<'a> Gen for ImportDeclaration<'a> { impl<'a> Gen for WithClause<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); - self.attributes_keyword.gen(p, ctx); + self.attributes_keyword.print(p, ctx); p.print_soft_space(); p.print_block_start(self.span.start); p.print_sequence(&self.with_entries, ctx); @@ -812,11 +833,11 @@ impl<'a> Gen for ImportAttribute<'a> { ImportAttributeKey::Identifier(identifier) => { p.print_str(identifier.name.as_str()); } - ImportAttributeKey::StringLiteral(literal) => literal.gen(p, ctx), + ImportAttributeKey::StringLiteral(literal) => literal.print(p, ctx), }; p.print_colon(); p.print_soft_space(); - self.value.gen(p, ctx); + self.value.print(p, ctx); } } @@ -853,14 +874,14 @@ impl<'a> Gen for ExportNamedDeclaration<'a> { match &self.declaration { Some(decl) => { match decl { - Declaration::VariableDeclaration(decl) => decl.gen(p, ctx), - Declaration::FunctionDeclaration(decl) => decl.gen(p, ctx), - Declaration::ClassDeclaration(decl) => decl.gen(p, ctx), - Declaration::TSModuleDeclaration(decl) => decl.gen(p, ctx), - Declaration::TSTypeAliasDeclaration(decl) => decl.gen(p, ctx), - Declaration::TSInterfaceDeclaration(decl) => decl.gen(p, ctx), - Declaration::TSEnumDeclaration(decl) => decl.gen(p, ctx), - Declaration::TSImportEqualsDeclaration(decl) => decl.gen(p, ctx), + Declaration::VariableDeclaration(decl) => decl.print(p, ctx), + Declaration::FunctionDeclaration(decl) => decl.print(p, ctx), + Declaration::ClassDeclaration(decl) => decl.print(p, ctx), + Declaration::TSModuleDeclaration(decl) => decl.print(p, ctx), + Declaration::TSTypeAliasDeclaration(decl) => decl.print(p, ctx), + Declaration::TSInterfaceDeclaration(decl) => decl.print(p, ctx), + Declaration::TSEnumDeclaration(decl) => decl.print(p, ctx), + Declaration::TSImportEqualsDeclaration(decl) => decl.print(p, ctx), } if matches!( decl, @@ -886,7 +907,7 @@ impl<'a> Gen for ExportNamedDeclaration<'a> { p.print_soft_space(); p.print_str("from"); p.print_soft_space(); - source.gen(p, ctx); + source.print(p, ctx); } p.print_semicolon_after_statement(); } @@ -898,7 +919,7 @@ impl<'a> Gen for TSExportAssignment<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_indent(); p.print_str("export = "); - self.expression.gen_expr(p, Precedence::Lowest, ctx); + self.expression.print_expr(p, Precedence::Lowest, ctx); p.print_semicolon_after_statement(); } } @@ -907,7 +928,7 @@ impl<'a> Gen for TSNamespaceExportDeclaration<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_indent(); p.print_str("export as namespace "); - self.id.gen(p, ctx); + self.id.print(p, ctx); p.print_semicolon_after_statement(); } } @@ -917,10 +938,10 @@ impl<'a> Gen for ExportSpecifier<'a> { if self.export_kind.is_type() { p.print_str("type "); } - self.local.gen(p, ctx); + self.local.print(p, ctx); if self.local.name() != self.exported.name() { p.print_str(" as "); - self.exported.gen(p, ctx); + self.exported.print(p, ctx); } } } @@ -929,8 +950,8 @@ impl<'a> Gen for ModuleExportName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { Self::IdentifierName(identifier) => p.print_str(identifier.name.as_str()), - Self::IdentifierReference(identifier) => identifier.gen(p, ctx), - Self::StringLiteral(literal) => literal.gen(p, ctx), + Self::IdentifierReference(identifier) => identifier.print(p, ctx), + Self::StringLiteral(literal) => literal.print(p, ctx), }; } } @@ -947,14 +968,14 @@ impl<'a> Gen for ExportAllDeclaration<'a> { if let Some(exported) = &self.exported { p.print_str(" as "); - exported.gen(p, ctx); + exported.print(p, ctx); } p.print_str(" from "); - self.source.gen(p, ctx); + self.source.print(p, ctx); if let Some(with_clause) = &self.with_clause { p.print_hard_space(); - with_clause.gen(p, ctx); + with_clause.print(p, ctx); } p.print_semicolon_after_statement(); } @@ -965,7 +986,7 @@ impl<'a> Gen for ExportDefaultDeclaration<'a> { p.add_source_mapping(self.span.start); p.print_indent(); p.print_str("export default "); - self.declaration.gen(p, ctx); + self.declaration.print(p, ctx); } } impl<'a> Gen for ExportDefaultDeclarationKind<'a> { @@ -973,18 +994,18 @@ impl<'a> Gen for ExportDefaultDeclarationKind<'a> { match self { match_expression!(Self) => { p.start_of_default_export = p.code_len(); - self.to_expression().gen_expr(p, Precedence::Comma, Context::empty()); + self.to_expression().print_expr(p, Precedence::Comma, Context::empty()); p.print_semicolon_after_statement(); } Self::FunctionDeclaration(fun) => { - fun.gen(p, ctx); + fun.print(p, ctx); p.print_soft_newline(); } Self::ClassDeclaration(class) => { - class.gen(p, ctx); + class.print(p, ctx); p.print_soft_newline(); } - Self::TSInterfaceDeclaration(interface) => interface.gen(p, ctx), + Self::TSInterfaceDeclaration(interface) => interface.print(p, ctx), } } } @@ -992,55 +1013,55 @@ impl<'a> Gen for ExportDefaultDeclarationKind<'a> { impl<'a> GenExpr for Expression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { match self { - Self::BooleanLiteral(lit) => lit.gen(p, ctx), - Self::NullLiteral(lit) => lit.gen(p, ctx), - Self::NumericLiteral(lit) => lit.gen(p, ctx), - Self::BigIntLiteral(lit) => lit.gen(p, ctx), - Self::RegExpLiteral(lit) => lit.gen(p, ctx), - Self::StringLiteral(lit) => lit.gen(p, ctx), - Self::Identifier(ident) => ident.gen(p, ctx), - Self::ThisExpression(expr) => expr.gen(p, ctx), + Self::BooleanLiteral(lit) => lit.print(p, ctx), + Self::NullLiteral(lit) => lit.print(p, ctx), + Self::NumericLiteral(lit) => lit.print(p, ctx), + Self::BigIntLiteral(lit) => lit.print(p, ctx), + Self::RegExpLiteral(lit) => lit.print(p, ctx), + Self::StringLiteral(lit) => lit.print(p, ctx), + Self::Identifier(ident) => ident.print(p, ctx), + Self::ThisExpression(expr) => expr.print(p, ctx), match_member_expression!(Self) => { - self.to_member_expression().gen_expr(p, precedence, ctx); - } - Self::CallExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::ArrayExpression(expr) => expr.gen(p, ctx), - Self::ObjectExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::FunctionExpression(expr) => expr.gen(p, ctx), - Self::ArrowFunctionExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::YieldExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::UpdateExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::UnaryExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::BinaryExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::PrivateInExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::LogicalExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::ConditionalExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::AssignmentExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::SequenceExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::ImportExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::TemplateLiteral(literal) => literal.gen(p, ctx), - Self::TaggedTemplateExpression(expr) => expr.gen(p, ctx), - Self::Super(sup) => sup.gen(p, ctx), - Self::AwaitExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::ChainExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::NewExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::MetaProperty(expr) => expr.gen(p, ctx), - Self::ClassExpression(expr) => expr.gen(p, ctx), - Self::JSXElement(el) => el.gen(p, ctx), - Self::JSXFragment(fragment) => fragment.gen(p, ctx), - Self::ParenthesizedExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSAsExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSSatisfiesExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSTypeAssertion(e) => e.gen_expr(p, precedence, ctx), - Self::TSNonNullExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSInstantiationExpression(e) => e.gen_expr(p, precedence, ctx), + self.to_member_expression().print_expr(p, precedence, ctx); + } + Self::CallExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::ArrayExpression(expr) => expr.print(p, ctx), + Self::ObjectExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::FunctionExpression(expr) => expr.print(p, ctx), + Self::ArrowFunctionExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::YieldExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::UpdateExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::UnaryExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::BinaryExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::PrivateInExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::LogicalExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::ConditionalExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::AssignmentExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::SequenceExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::ImportExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::TemplateLiteral(literal) => literal.print(p, ctx), + Self::TaggedTemplateExpression(expr) => expr.print(p, ctx), + Self::Super(sup) => sup.print(p, ctx), + Self::AwaitExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::ChainExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::NewExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::MetaProperty(expr) => expr.print(p, ctx), + Self::ClassExpression(expr) => expr.print(p, ctx), + Self::JSXElement(el) => el.print(p, ctx), + Self::JSXFragment(fragment) => fragment.print(p, ctx), + Self::ParenthesizedExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSAsExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSSatisfiesExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSTypeAssertion(e) => e.print_expr(p, precedence, ctx), + Self::TSNonNullExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSInstantiationExpression(e) => e.print_expr(p, precedence, ctx), } } } impl<'a> GenExpr for ParenthesizedExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { - self.expression.gen_expr(p, precedence, ctx); + self.expression.print_expr(p, precedence, ctx); } } @@ -1331,28 +1352,28 @@ impl Gen for ThisExpression { impl<'a> GenExpr for MemberExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { match self { - Self::ComputedMemberExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::StaticMemberExpression(expr) => expr.gen_expr(p, precedence, ctx), - Self::PrivateFieldExpression(expr) => expr.gen_expr(p, precedence, ctx), + Self::ComputedMemberExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::StaticMemberExpression(expr) => expr.print_expr(p, precedence, ctx), + Self::PrivateFieldExpression(expr) => expr.print_expr(p, precedence, ctx), } } } impl<'a> GenExpr for ComputedMemberExpression<'a> { fn gen_expr(&self, p: &mut Codegen, _precedence: Precedence, ctx: Context) { - self.object.gen_expr(p, Precedence::Prefix, ctx.intersection(Context::FORBID_CALL)); + self.object.print_expr(p, Precedence::Prefix, ctx.intersection(Context::FORBID_CALL)); if self.optional { p.print_str("?."); } p.print_char(b'['); - self.expression.gen_expr(p, Precedence::Lowest, Context::empty()); + self.expression.print_expr(p, Precedence::Lowest, Context::empty()); p.print_char(b']'); } } impl<'a> GenExpr for StaticMemberExpression<'a> { fn gen_expr(&self, p: &mut Codegen, _precedence: Precedence, ctx: Context) { - self.object.gen_expr(p, Precedence::Postfix, ctx.intersection(Context::FORBID_CALL)); + self.object.print_expr(p, Precedence::Postfix, ctx.intersection(Context::FORBID_CALL)); if self.optional { p.print_char(b'?'); } else if p.need_space_before_dot == p.code_len() { @@ -1360,18 +1381,18 @@ impl<'a> GenExpr for StaticMemberExpression<'a> { p.print_hard_space(); } p.print_char(b'.'); - self.property.gen(p, ctx); + self.property.print(p, ctx); } } impl<'a> GenExpr for PrivateFieldExpression<'a> { fn gen_expr(&self, p: &mut Codegen, _precedence: Precedence, ctx: Context) { - self.object.gen_expr(p, Precedence::Prefix, ctx.intersection(Context::FORBID_CALL)); + self.object.print_expr(p, Precedence::Prefix, ctx.intersection(Context::FORBID_CALL)); if self.optional { p.print_str("?"); } p.print_char(b'.'); - self.field.gen(p, ctx); + self.field.print(p, ctx); } } @@ -1385,12 +1406,12 @@ impl<'a> GenExpr for CallExpression<'a> { p.wrap(wrap, |p| { p.print_comments(&annotate_comments, &mut AnnotationKind::empty()); p.add_source_mapping(self.span.start); - self.callee.gen_expr(p, Precedence::Postfix, Context::empty()); + self.callee.print_expr(p, Precedence::Postfix, Context::empty()); if self.optional { p.print_str("?."); } if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_char(b'('); p.print_list(&self.arguments, ctx); @@ -1403,9 +1424,9 @@ impl<'a> GenExpr for CallExpression<'a> { impl<'a> Gen for Argument<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::SpreadElement(elem) => elem.gen(p, ctx), + Self::SpreadElement(elem) => elem.print(p, ctx), match_expression!(Self) => { - self.to_expression().gen_expr(p, Precedence::Comma, Context::empty()); + self.to_expression().print_expr(p, Precedence::Comma, Context::empty()); } } } @@ -1415,9 +1436,9 @@ impl<'a> Gen for ArrayExpressionElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { match_expression!(Self) => { - self.to_expression().gen_expr(p, Precedence::Comma, Context::empty()); + self.to_expression().print_expr(p, Precedence::Comma, Context::empty()); } - Self::SpreadElement(elem) => elem.gen(p, ctx), + Self::SpreadElement(elem) => elem.print(p, ctx), Self::Elision(_span) => p.print_comma(), } } @@ -1427,7 +1448,7 @@ impl<'a> Gen for SpreadElement<'a> { fn gen(&self, p: &mut Codegen, _ctx: Context) { p.add_source_mapping(self.span.start); p.print_ellipsis(); - self.argument.gen_expr(p, Precedence::Comma, Context::empty()); + self.argument.print_expr(p, Precedence::Comma, Context::empty()); } } @@ -1436,7 +1457,7 @@ impl<'a> Gen for ArrayExpression<'a> { p.add_source_mapping(self.span.start); p.print_char(b'['); for (index, item) in self.elements.iter().enumerate() { - item.gen(p, ctx); + item.print(p, ctx); if index != self.elements.len() - 1 { if !matches!(item, ArrayExpressionElement::Elision(_)) { p.print_comma(); @@ -1453,7 +1474,7 @@ impl<'a> GenExpr for ObjectExpression<'a> { fn gen_expr(&self, p: &mut Codegen, _precedence: Precedence, ctx: Context) { let n = p.code_len(); let len = self.properties.len(); - let is_multi_line = len > 1; + let is_multi_line = len > 0; let wrap = p.start_of_stmt == n || p.start_of_arrow_expr == n; p.wrap(wrap, |p| { p.add_source_mapping(self.span.start); @@ -1471,7 +1492,7 @@ impl<'a> GenExpr for ObjectExpression<'a> { } else { p.print_soft_space(); } - item.gen(p, ctx); + item.print(p, ctx); } if is_multi_line { p.print_soft_newline(); @@ -1489,8 +1510,8 @@ impl<'a> GenExpr for ObjectExpression<'a> { impl<'a> Gen for ObjectPropertyKind<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::ObjectProperty(prop) => prop.gen(p, ctx), - Self::SpreadProperty(elem) => elem.gen(p, ctx), + Self::ObjectProperty(prop) => prop.print(p, ctx), + Self::SpreadProperty(elem) => elem.print(p, ctx), } } } @@ -1522,19 +1543,19 @@ impl<'a> Gen for ObjectProperty<'a> { if self.computed { p.print_char(b'['); } - self.key.gen(p, ctx); + self.key.print(p, ctx); if self.computed { p.print_char(b']'); } if let Some(type_parameters) = &func.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_char(b'('); - func.params.gen(p, ctx); + func.params.print(p, ctx); p.print_char(b')'); if let Some(body) = &func.body { p.print_soft_space(); - body.gen(p, ctx); + body.print(p, ctx); } return; } @@ -1553,7 +1574,7 @@ impl<'a> Gen for ObjectProperty<'a> { p.print_char(b'['); } if !shorthand { - self.key.gen(p, ctx); + self.key.print(p, ctx); } if self.computed { p.print_char(b']'); @@ -1562,17 +1583,17 @@ impl<'a> Gen for ObjectProperty<'a> { p.print_colon(); p.print_soft_space(); } - self.value.gen_expr(p, Precedence::Comma, Context::empty()); + self.value.print_expr(p, Precedence::Comma, Context::empty()); } } impl<'a> Gen for PropertyKey<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::StaticIdentifier(ident) => ident.gen(p, ctx), - Self::PrivateIdentifier(ident) => ident.gen(p, ctx), + Self::StaticIdentifier(ident) => ident.print(p, ctx), + Self::PrivateIdentifier(ident) => ident.print(p, ctx), match_expression!(Self) => { - self.to_expression().gen_expr(p, Precedence::Comma, Context::empty()); + self.to_expression().print_expr(p, Precedence::Comma, Context::empty()); } } } @@ -1592,16 +1613,16 @@ impl<'a> GenExpr for ArrowFunctionExpression<'a> { } if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.add_source_mapping(self.span.start); p.print_char(b'('); - self.params.gen(p, ctx); + self.params.print(p, ctx); p.print_char(b')'); if let Some(return_type) = &self.return_type { p.print_str(":"); p.print_soft_space(); - return_type.gen(p, ctx); + return_type.print(p, ctx); } p.print_soft_space(); p.print_str("=>"); @@ -1609,10 +1630,10 @@ impl<'a> GenExpr for ArrowFunctionExpression<'a> { if self.expression { if let Some(Statement::ExpressionStatement(stmt)) = &self.body.statements.first() { p.start_of_arrow_expr = p.code_len(); - stmt.expression.gen_expr(p, Precedence::Comma, ctx.and_forbid_in(true)); + stmt.expression.print_expr(p, Precedence::Comma, ctx.and_forbid_in(true)); } } else { - self.body.gen(p, ctx); + self.body.print(p, ctx); } }); } @@ -1632,7 +1653,7 @@ impl<'a> GenExpr for YieldExpression<'a> { if !self.delegate { p.print_hard_space(); } - argument.gen_expr(p, Precedence::Yield, Context::empty()); + argument.print_expr(p, Precedence::Yield, Context::empty()); } }); } @@ -1648,10 +1669,10 @@ impl<'a> GenExpr for UpdateExpression<'a> { p.print_str(operator); p.prev_op = Some(self.operator.into()); p.prev_op_end = p.code().len(); - self.argument.gen_expr(p, Precedence::Prefix, ctx); + self.argument.print_expr(p, Precedence::Prefix, ctx); } else { p.print_space_before_operator(self.operator.into()); - self.argument.gen_expr(p, Precedence::Postfix, ctx); + self.argument.print_expr(p, Precedence::Postfix, ctx); p.print_str(operator); p.prev_op = Some(self.operator.into()); p.prev_op_end = p.code().len(); @@ -1674,7 +1695,7 @@ impl<'a> GenExpr for UnaryExpression<'a> { p.prev_op = Some(self.operator.into()); p.prev_op_end = p.code().len(); } - self.argument.gen_expr(p, Precedence::Exponentiation, ctx); + self.argument.print_expr(p, Precedence::Exponentiation, ctx); }); } } @@ -1702,9 +1723,9 @@ impl<'a> GenExpr for BinaryExpression<'a> { impl<'a> GenExpr for PrivateInExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { p.wrap(precedence >= Precedence::Compare, |p| { - self.left.gen(p, ctx); + self.left.print(p, ctx); p.print_str(" in "); - self.right.gen_expr(p, Precedence::Equals, Context::empty()); + self.right.print_expr(p, Precedence::Equals, Context::empty()); }); } } @@ -1737,15 +1758,15 @@ impl<'a> GenExpr for ConditionalExpression<'a> { ctx &= Context::FORBID_IN.not(); } p.wrap(wrap, |p| { - self.test.gen_expr(p, Precedence::Conditional, ctx & Context::FORBID_IN); + self.test.print_expr(p, Precedence::Conditional, ctx & Context::FORBID_IN); p.print_soft_space(); p.print_char(b'?'); p.print_soft_space(); - self.consequent.gen_expr(p, Precedence::Yield, Context::empty()); + self.consequent.print_expr(p, Precedence::Yield, Context::empty()); p.print_soft_space(); p.print_colon(); p.print_soft_space(); - self.alternate.gen_expr(p, Precedence::Yield, ctx & Context::FORBID_IN); + self.alternate.print_expr(p, Precedence::Yield, ctx & Context::FORBID_IN); }); } } @@ -1778,11 +1799,11 @@ impl<'a> GenExpr for AssignmentExpression<'a> { && matches!(self.left, AssignmentTarget::ObjectAssignmentTarget(_))) || identifier_is_keyword; p.wrap(wrap || precedence >= self.precedence(), |p| { - self.left.gen(p, ctx); + self.left.print(p, ctx); p.print_soft_space(); p.print_str(self.operator.as_str()); p.print_soft_space(); - self.right.gen_expr(p, Precedence::Comma, ctx); + self.right.print_expr(p, Precedence::Comma, ctx); }); } } @@ -1791,10 +1812,14 @@ impl<'a> Gen for AssignmentTarget<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { match_simple_assignment_target!(Self) => { - self.to_simple_assignment_target().gen_expr(p, Precedence::Comma, Context::empty()); + self.to_simple_assignment_target().print_expr( + p, + Precedence::Comma, + Context::empty(), + ); } match_assignment_target_pattern!(Self) => { - self.to_assignment_target_pattern().gen(p, ctx); + self.to_assignment_target_pattern().print(p, ctx); } } } @@ -1803,15 +1828,15 @@ impl<'a> Gen for AssignmentTarget<'a> { impl<'a> GenExpr for SimpleAssignmentTarget<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { match self { - Self::AssignmentTargetIdentifier(ident) => ident.gen(p, ctx), + Self::AssignmentTargetIdentifier(ident) => ident.print(p, ctx), match_member_expression!(Self) => { - self.to_member_expression().gen_expr(p, precedence, ctx); + self.to_member_expression().print_expr(p, precedence, ctx); } - Self::TSAsExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSSatisfiesExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSNonNullExpression(e) => e.gen_expr(p, precedence, ctx), - Self::TSTypeAssertion(e) => e.gen_expr(p, precedence, ctx), - Self::TSInstantiationExpression(e) => e.gen_expr(p, precedence, ctx), + Self::TSAsExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSSatisfiesExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSNonNullExpression(e) => e.print_expr(p, precedence, ctx), + Self::TSTypeAssertion(e) => e.print_expr(p, precedence, ctx), + Self::TSInstantiationExpression(e) => e.print_expr(p, precedence, ctx), } } } @@ -1819,8 +1844,8 @@ impl<'a> GenExpr for SimpleAssignmentTarget<'a> { impl<'a> Gen for AssignmentTargetPattern<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::ArrayAssignmentTarget(target) => target.gen(p, ctx), - Self::ObjectAssignmentTarget(target) => target.gen(p, ctx), + Self::ArrayAssignmentTarget(target) => target.print(p, ctx), + Self::ObjectAssignmentTarget(target) => target.print(p, ctx), } } } @@ -1835,7 +1860,7 @@ impl<'a> Gen for ArrayAssignmentTarget<'a> { p.print_soft_space(); } if let Some(item) = item { - item.gen(p, ctx); + item.print(p, ctx); } } if let Some(target) = &self.rest { @@ -1843,7 +1868,7 @@ impl<'a> Gen for ArrayAssignmentTarget<'a> { p.print_comma(); } p.add_source_mapping(self.span.start); - target.gen(p, ctx); + target.print(p, ctx); } if self.trailing_comma.is_some() { p.print_comma(); @@ -1863,7 +1888,7 @@ impl<'a> Gen for ObjectAssignmentTarget<'a> { p.print_comma(); } p.add_source_mapping(self.span.start); - target.gen(p, ctx); + target.print(p, ctx); } p.print_char(b'}'); p.add_source_mapping(self.span.end); @@ -1873,27 +1898,27 @@ impl<'a> Gen for ObjectAssignmentTarget<'a> { impl<'a> Gen for AssignmentTargetMaybeDefault<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - match_assignment_target!(Self) => self.to_assignment_target().gen(p, ctx), - Self::AssignmentTargetWithDefault(target) => target.gen(p, ctx), + match_assignment_target!(Self) => self.to_assignment_target().print(p, ctx), + Self::AssignmentTargetWithDefault(target) => target.print(p, ctx), } } } impl<'a> Gen for AssignmentTargetWithDefault<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.binding.gen(p, ctx); + self.binding.print(p, ctx); p.print_soft_space(); p.print_equal(); p.print_soft_space(); - self.init.gen_expr(p, Precedence::Comma, Context::empty()); + self.init.print_expr(p, Precedence::Comma, Context::empty()); } } impl<'a> Gen for AssignmentTargetProperty<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::AssignmentTargetPropertyIdentifier(ident) => ident.gen(p, ctx), - Self::AssignmentTargetPropertyProperty(prop) => prop.gen(p, ctx), + Self::AssignmentTargetPropertyIdentifier(ident) => ident.print(p, ctx), + Self::AssignmentTargetPropertyProperty(prop) => prop.print(p, ctx), } } } @@ -1902,7 +1927,7 @@ impl<'a> Gen for AssignmentTargetPropertyIdentifier<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { let ident_name = p.get_identifier_reference_name(&self.binding).to_owned(); if ident_name == self.binding.name.as_str() { - self.binding.gen(p, ctx); + self.binding.print(p, ctx); } else { // `({x: a} = y);` p.print_str(self.binding.name.as_str()); @@ -1914,7 +1939,7 @@ impl<'a> Gen for AssignmentTargetPropertyIdentifier<'a> { p.print_soft_space(); p.print_equal(); p.print_soft_space(); - expr.gen_expr(p, Precedence::Comma, Context::empty()); + expr.print_expr(p, Precedence::Comma, Context::empty()); } } } @@ -1923,27 +1948,27 @@ impl<'a> Gen for AssignmentTargetPropertyProperty<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match &self.name { PropertyKey::StaticIdentifier(ident) => { - ident.gen(p, ctx); + ident.print(p, ctx); } PropertyKey::PrivateIdentifier(ident) => { - ident.gen(p, ctx); + ident.print(p, ctx); } key @ match_expression!(PropertyKey) => { p.print_char(b'['); - key.to_expression().gen_expr(p, Precedence::Comma, Context::empty()); + key.to_expression().print_expr(p, Precedence::Comma, Context::empty()); p.print_char(b']'); } } p.print_colon(); p.print_soft_space(); - self.binding.gen(p, ctx); + self.binding.print(p, ctx); } } impl<'a> Gen for AssignmentTargetRest<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_ellipsis(); - self.target.gen(p, ctx); + self.target.print(p, ctx); } } @@ -1961,7 +1986,7 @@ impl<'a> GenExpr for ImportExpression<'a> { p.wrap(wrap, |p| { p.add_source_mapping(self.span.start); p.print_str("import("); - self.source.gen_expr(p, Precedence::Comma, Context::empty()); + self.source.print_expr(p, Precedence::Comma, Context::empty()); if !self.arguments.is_empty() { p.print_comma(); p.print_expressions(&self.arguments, Precedence::Comma, Context::empty()); @@ -1994,11 +2019,11 @@ impl<'a> Gen for TemplateLiteral<'a> { impl<'a> Gen for TaggedTemplateExpression<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); - self.tag.gen_expr(p, Precedence::Postfix, Context::empty()); + self.tag.print_expr(p, Precedence::Postfix, Context::empty()); if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } - self.quasi.gen(p, ctx); + self.quasi.print(p, ctx); } } @@ -2014,7 +2039,7 @@ impl<'a> GenExpr for AwaitExpression<'a> { p.wrap(precedence >= self.precedence(), |p| { p.add_source_mapping(self.span.start); p.print_str("await "); - self.argument.gen_expr(p, Precedence::Exponentiation, ctx); + self.argument.print_expr(p, Precedence::Exponentiation, ctx); }); } } @@ -2022,9 +2047,9 @@ impl<'a> GenExpr for AwaitExpression<'a> { impl<'a> GenExpr for ChainExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { match &self.expression { - ChainElement::CallExpression(expr) => expr.gen_expr(p, precedence, ctx), + ChainElement::CallExpression(expr) => expr.print_expr(p, precedence, ctx), match_member_expression!(ChainElement) => { - self.expression.to_member_expression().gen_expr(p, precedence, ctx); + self.expression.to_member_expression().print_expr(p, precedence, ctx); } } } @@ -2042,7 +2067,7 @@ impl<'a> GenExpr for NewExpression<'a> { p.print_space_before_identifier(); p.add_source_mapping(self.span.start); p.print_str("new "); - self.callee.gen_expr(p, Precedence::New, Context::FORBID_CALL); + self.callee.print_expr(p, Precedence::New, Context::FORBID_CALL); p.print_char(b'('); p.print_list(&self.arguments, ctx); p.print_char(b')'); @@ -2054,10 +2079,10 @@ impl<'a> GenExpr for TSAsExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { p.print_char(b'('); p.print_char(b'('); - self.expression.gen_expr(p, precedence, Context::default()); + self.expression.print_expr(p, precedence, Context::default()); p.print_char(b')'); p.print_str(" as "); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); p.print_char(b')'); } } @@ -2066,10 +2091,10 @@ impl<'a> GenExpr for TSSatisfiesExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { p.print_char(b'('); p.print_char(b'('); - self.expression.gen_expr(p, precedence, Context::default()); + self.expression.print_expr(p, precedence, Context::default()); p.print_char(b')'); p.print_str(" satisfies "); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); p.print_char(b')'); } } @@ -2077,7 +2102,7 @@ impl<'a> GenExpr for TSSatisfiesExpression<'a> { impl<'a> GenExpr for TSNonNullExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { p.wrap(matches!(self.expression, Expression::ParenthesizedExpression(_)), |p| { - self.expression.gen_expr(p, precedence, ctx); + self.expression.print_expr(p, precedence, ctx); }); p.print_char(b'!'); if p.options.minify { @@ -2088,8 +2113,8 @@ impl<'a> GenExpr for TSNonNullExpression<'a> { impl<'a> GenExpr for TSInstantiationExpression<'a> { fn gen_expr(&self, p: &mut Codegen, precedence: Precedence, ctx: Context) { - self.expression.gen_expr(p, precedence, ctx); - self.type_parameters.gen(p, ctx); + self.expression.print_expr(p, precedence, ctx); + self.type_parameters.print(p, ctx); if p.options.minify { p.print_hard_space(); } @@ -2105,9 +2130,9 @@ impl<'a> GenExpr for TSTypeAssertion<'a> { if matches!(self.type_annotation, TSType::TSFunctionType(_)) { p.print_hard_space(); } - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); p.print_str(">"); - self.expression.gen_expr(p, Precedence::Member, ctx); + self.expression.print_expr(p, Precedence::Member, ctx); }); } } @@ -2115,9 +2140,9 @@ impl<'a> GenExpr for TSTypeAssertion<'a> { impl<'a> Gen for MetaProperty<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); - self.meta.gen(p, ctx); + self.meta.print(p, ctx); p.print_char(b'.'); - self.property.gen(p, ctx); + self.property.print(p, ctx); } } @@ -2128,7 +2153,7 @@ impl<'a> Gen for Class<'a> { let wrap = self.is_expression() && (p.start_of_stmt == n || p.start_of_default_export == n); p.wrap(wrap, |p| { for decorator in &self.decorators { - decorator.gen(p, ctx); + decorator.print(p, ctx); p.print_hard_space(); } if self.declare { @@ -2140,16 +2165,16 @@ impl<'a> Gen for Class<'a> { p.print_str("class"); if let Some(id) = &self.id { p.print_hard_space(); - id.gen(p, ctx); + id.print(p, ctx); if let Some(type_parameters) = self.type_parameters.as_ref() { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } } if let Some(super_class) = self.super_class.as_ref() { p.print_str(" extends "); - super_class.gen_expr(p, Precedence::Call, Context::empty()); + super_class.print_expr(p, Precedence::Call, Context::empty()); if let Some(super_type_parameters) = &self.super_type_parameters { - super_type_parameters.gen(p, ctx); + super_type_parameters.print(p, ctx); } } if let Some(implements) = self.implements.as_ref() { @@ -2157,7 +2182,7 @@ impl<'a> Gen for Class<'a> { p.print_list(implements, ctx); } p.print_soft_space(); - self.body.gen(p, ctx); + self.body.print(p, ctx); p.needs_semicolon = false; }); } @@ -2169,7 +2194,7 @@ impl<'a> Gen for ClassBody<'a> { for item in &self.body { p.print_semicolon_if_needed(); p.print_indent(); - item.gen(p, ctx); + item.print(p, ctx); } }); } @@ -2179,23 +2204,23 @@ impl<'a> Gen for ClassElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { Self::StaticBlock(elem) => { - elem.gen(p, ctx); + elem.print(p, ctx); p.print_soft_newline(); } Self::MethodDefinition(elem) => { - elem.gen(p, ctx); + elem.print(p, ctx); p.print_soft_newline(); } Self::PropertyDefinition(elem) => { - elem.gen(p, ctx); + elem.print(p, ctx); p.print_semicolon_after_statement(); } Self::AccessorProperty(elem) => { - elem.gen(p, ctx); + elem.print(p, ctx); p.print_semicolon_after_statement(); } Self::TSIndexSignature(elem) => { - elem.gen(p, ctx); + elem.print(p, ctx); p.print_semicolon_after_statement(); } } @@ -2212,56 +2237,56 @@ impl<'a> Gen for JSXIdentifier<'a> { impl<'a> Gen for JSXMemberExpressionObject<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::IdentifierReference(ident) => ident.gen(p, ctx), - Self::MemberExpression(member_expr) => member_expr.gen(p, ctx), - Self::ThisExpression(expr) => expr.gen(p, ctx), + Self::IdentifierReference(ident) => ident.print(p, ctx), + Self::MemberExpression(member_expr) => member_expr.print(p, ctx), + Self::ThisExpression(expr) => expr.print(p, ctx), } } } impl<'a> Gen for JSXMemberExpression<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.object.gen(p, ctx); + self.object.print(p, ctx); p.print_char(b'.'); - self.property.gen(p, ctx); + self.property.print(p, ctx); } } impl<'a> Gen for JSXElementName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::Identifier(identifier) => identifier.gen(p, ctx), - Self::IdentifierReference(identifier) => identifier.gen(p, ctx), - Self::NamespacedName(namespaced_name) => namespaced_name.gen(p, ctx), - Self::MemberExpression(member_expr) => member_expr.gen(p, ctx), - Self::ThisExpression(expr) => expr.gen(p, ctx), + Self::Identifier(identifier) => identifier.print(p, ctx), + Self::IdentifierReference(identifier) => identifier.print(p, ctx), + Self::NamespacedName(namespaced_name) => namespaced_name.print(p, ctx), + Self::MemberExpression(member_expr) => member_expr.print(p, ctx), + Self::ThisExpression(expr) => expr.print(p, ctx), } } } impl<'a> Gen for JSXNamespacedName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.namespace.gen(p, ctx); + self.namespace.print(p, ctx); p.print_colon(); - self.property.gen(p, ctx); + self.property.print(p, ctx); } } impl<'a> Gen for JSXAttributeName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::Identifier(ident) => ident.gen(p, ctx), - Self::NamespacedName(namespaced_name) => namespaced_name.gen(p, ctx), + Self::Identifier(ident) => ident.print(p, ctx), + Self::NamespacedName(namespaced_name) => namespaced_name.print(p, ctx), } } } impl<'a> Gen for JSXAttribute<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.name.gen(p, ctx); + self.name.print(p, ctx); if let Some(value) = &self.value { p.print_equal(); - value.gen(p, ctx); + value.print(p, ctx); } } } @@ -2274,7 +2299,7 @@ impl<'a> Gen for JSXExpression<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { match_expression!(Self) => p.print_expression(self.to_expression()), - Self::EmptyExpression(expr) => expr.gen(p, ctx), + Self::EmptyExpression(expr) => expr.print(p, ctx), } } } @@ -2282,7 +2307,7 @@ impl<'a> Gen for JSXExpression<'a> { impl<'a> Gen for JSXExpressionContainer<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_char(b'{'); - self.expression.gen(p, ctx); + self.expression.print(p, ctx); p.print_char(b'}'); } } @@ -2290,15 +2315,15 @@ impl<'a> Gen for JSXExpressionContainer<'a> { impl<'a> Gen for JSXAttributeValue<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::Fragment(fragment) => fragment.gen(p, ctx), - Self::Element(el) => el.gen(p, ctx), + Self::Fragment(fragment) => fragment.print(p, ctx), + Self::Element(el) => el.print(p, ctx), Self::StringLiteral(lit) => { let quote = if lit.value.contains('"') { b'\'' } else { b'"' }; p.print_char(quote); p.print_str(&lit.value); p.print_char(quote); } - Self::ExpressionContainer(expr_container) => expr_container.gen(p, ctx), + Self::ExpressionContainer(expr_container) => expr_container.print(p, ctx), } } } @@ -2306,7 +2331,7 @@ impl<'a> Gen for JSXAttributeValue<'a> { impl<'a> Gen for JSXSpreadAttribute<'a> { fn gen(&self, p: &mut Codegen, _ctx: Context) { p.print_str("{..."); - self.argument.gen_expr(p, Precedence::Comma, Context::empty()); + self.argument.print_expr(p, Precedence::Comma, Context::empty()); p.print_char(b'}'); } } @@ -2314,8 +2339,8 @@ impl<'a> Gen for JSXSpreadAttribute<'a> { impl<'a> Gen for JSXAttributeItem<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::Attribute(attr) => attr.gen(p, ctx), - Self::SpreadAttribute(spread_attr) => spread_attr.gen(p, ctx), + Self::Attribute(attr) => attr.print(p, ctx), + Self::SpreadAttribute(spread_attr) => spread_attr.print(p, ctx), } } } @@ -2324,7 +2349,7 @@ impl<'a> Gen for JSXOpeningElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); p.print_char(b'<'); - self.name.gen(p, ctx); + self.name.print(p, ctx); for attr in &self.attributes { match attr { JSXAttributeItem::Attribute(_) => { @@ -2334,7 +2359,7 @@ impl<'a> Gen for JSXOpeningElement<'a> { p.print_soft_space(); } } - attr.gen(p, ctx); + attr.print(p, ctx); } if self.self_closing { p.print_soft_space(); @@ -2348,19 +2373,19 @@ impl<'a> Gen for JSXClosingElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); p.print_str("'); } } impl<'a> Gen for JSXElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.opening_element.gen(p, ctx); + self.opening_element.print(p, ctx); for child in &self.children { - child.gen(p, ctx); + child.print(p, ctx); } if let Some(closing_element) = &self.closing_element { - closing_element.gen(p, ctx); + closing_element.print(p, ctx); } } } @@ -2396,22 +2421,22 @@ impl<'a> Gen for JSXSpreadChild<'a> { impl<'a> Gen for JSXChild<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::Fragment(fragment) => fragment.gen(p, ctx), - Self::Element(el) => el.gen(p, ctx), + Self::Fragment(fragment) => fragment.print(p, ctx), + Self::Element(el) => el.print(p, ctx), Self::Spread(spread) => p.print_expression(&spread.expression), - Self::ExpressionContainer(expr_container) => expr_container.gen(p, ctx), - Self::Text(text) => text.gen(p, ctx), + Self::ExpressionContainer(expr_container) => expr_container.print(p, ctx), + Self::Text(text) => text.print(p, ctx), } } } impl<'a> Gen for JSXFragment<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.opening_fragment.gen(p, ctx); + self.opening_fragment.print(p, ctx); for child in &self.children { - child.gen(p, ctx); + child.print(p, ctx); } - self.closing_fragment.gen(p, ctx); + self.closing_fragment.print(p, ctx); } } @@ -2423,7 +2448,7 @@ impl<'a> Gen for StaticBlock<'a> { p.print_curly_braces(self.span, self.body.is_empty(), |p| { for stmt in &self.body { p.print_semicolon_if_needed(); - stmt.gen(p, ctx); + stmt.print(p, ctx); } }); p.needs_semicolon = false; @@ -2434,7 +2459,7 @@ impl<'a> Gen for MethodDefinition<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); for decorator in &self.decorators { - decorator.gen(p, ctx); + decorator.print(p, ctx); p.print_hard_space(); } @@ -2470,7 +2495,7 @@ impl<'a> Gen for MethodDefinition<'a> { if self.computed { p.print_char(b'['); } - self.key.gen(p, ctx); + self.key.print(p, ctx); if self.computed { p.print_char(b']'); } @@ -2478,19 +2503,19 @@ impl<'a> Gen for MethodDefinition<'a> { p.print_char(b'?'); } if let Some(type_parameters) = self.value.type_parameters.as_ref() { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_char(b'('); - self.value.params.gen(p, ctx); + self.value.params.print(p, ctx); p.print_char(b')'); if let Some(return_type) = &self.value.return_type { p.print_colon(); p.print_soft_space(); - return_type.gen(p, ctx); + return_type.print(p, ctx); } if let Some(body) = &self.value.body { p.print_soft_space(); - body.gen(p, ctx); + body.print(p, ctx); } else { p.print_semicolon(); } @@ -2501,7 +2526,7 @@ impl<'a> Gen for PropertyDefinition<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); for decorator in &self.decorators { - decorator.gen(p, ctx); + decorator.print(p, ctx); p.print_hard_space(); } if self.declare { @@ -2523,7 +2548,7 @@ impl<'a> Gen for PropertyDefinition<'a> { if self.computed { p.print_char(b'['); } - self.key.gen(p, ctx); + self.key.print(p, ctx); if self.computed { p.print_char(b']'); } @@ -2533,13 +2558,13 @@ impl<'a> Gen for PropertyDefinition<'a> { if let Some(type_annotation) = &self.type_annotation { p.print_colon(); p.print_soft_space(); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } if let Some(value) = &self.value { p.print_soft_space(); p.print_equal(); p.print_soft_space(); - value.gen_expr(p, Precedence::Comma, Context::empty()); + value.print_expr(p, Precedence::Comma, Context::empty()); } } } @@ -2548,7 +2573,7 @@ impl<'a> Gen for AccessorProperty<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); for decorator in &self.decorators { - decorator.gen(p, ctx); + decorator.print(p, ctx); p.print_hard_space(); } if self.r#type.is_abstract() { @@ -2568,20 +2593,20 @@ impl<'a> Gen for AccessorProperty<'a> { } else { p.print_hard_space(); } - self.key.gen(p, ctx); + self.key.print(p, ctx); if self.computed { p.print_char(b']'); } if let Some(type_annotation) = &self.type_annotation { p.print_colon(); p.print_soft_space(); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } if let Some(value) = &self.value { p.print_soft_space(); p.print_equal(); p.print_soft_space(); - value.gen_expr(p, Precedence::Comma, Context::empty()); + value.print_expr(p, Precedence::Comma, Context::empty()); } } } @@ -2597,10 +2622,10 @@ impl<'a> Gen for PrivateIdentifier<'a> { impl<'a> Gen for BindingPattern<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match &self.kind { - BindingPatternKind::BindingIdentifier(ident) => ident.gen(p, ctx), - BindingPatternKind::ObjectPattern(pattern) => pattern.gen(p, ctx), - BindingPatternKind::ArrayPattern(pattern) => pattern.gen(p, ctx), - BindingPatternKind::AssignmentPattern(pattern) => pattern.gen(p, ctx), + BindingPatternKind::BindingIdentifier(ident) => ident.print(p, ctx), + BindingPatternKind::ObjectPattern(pattern) => pattern.print(p, ctx), + BindingPatternKind::ArrayPattern(pattern) => pattern.print(p, ctx), + BindingPatternKind::AssignmentPattern(pattern) => pattern.print(p, ctx), } if self.optional { p.print_str("?"); @@ -2608,7 +2633,7 @@ impl<'a> Gen for BindingPattern<'a> { if let Some(type_annotation) = &self.type_annotation { p.print_colon(); p.print_soft_space(); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } } } @@ -2623,7 +2648,7 @@ impl<'a> Gen for ObjectPattern<'a> { if !self.properties.is_empty() { p.print_comma(); } - rest.gen(p, ctx); + rest.print(p, ctx); } p.print_soft_space(); p.print_char(b'}'); @@ -2660,7 +2685,7 @@ impl<'a> Gen for BindingProperty<'a> { } if !shorthand { - self.key.gen(p, ctx); + self.key.print(p, ctx); } if self.computed { p.print_char(b']'); @@ -2669,7 +2694,7 @@ impl<'a> Gen for BindingProperty<'a> { p.print_colon(); p.print_soft_space(); } - self.value.gen(p, ctx); + self.value.print(p, ctx); } } @@ -2677,7 +2702,7 @@ impl<'a> Gen for BindingRestElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.add_source_mapping(self.span.start); p.print_ellipsis(); - self.argument.gen(p, ctx); + self.argument.print(p, ctx); } } @@ -2691,7 +2716,7 @@ impl<'a> Gen for ArrayPattern<'a> { p.print_soft_space(); } if let Some(item) = item { - item.gen(p, ctx); + item.print(p, ctx); } if index == self.elements.len() - 1 && (item.is_none() || self.rest.is_some()) { p.print_comma(); @@ -2699,7 +2724,7 @@ impl<'a> Gen for ArrayPattern<'a> { } if let Some(rest) = &self.rest { p.print_soft_space(); - rest.gen(p, ctx); + rest.print(p, ctx); } p.print_char(b']'); p.add_source_mapping(self.span.end); @@ -2708,11 +2733,11 @@ impl<'a> Gen for ArrayPattern<'a> { impl<'a> Gen for AssignmentPattern<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.left.gen(p, ctx); + self.left.print(p, ctx); p.print_soft_space(); p.print_equal(); p.print_soft_space(); - self.right.gen_expr(p, Precedence::Comma, Context::empty()); + self.right.print_expr(p, Precedence::Comma, Context::empty()); } } @@ -2738,16 +2763,16 @@ impl<'a> Gen for Decorator<'a> { p.print_char(b'@'); let wrap = need_wrap(&self.expression); p.wrap(wrap, |p| { - self.expression.gen_expr(p, Precedence::Lowest, Context::empty()); + self.expression.print_expr(p, Precedence::Lowest, Context::empty()); }); } } impl<'a> Gen for TSClassImplements<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.expression.gen(p, ctx); + self.expression.print(p, ctx); if let Some(type_parameters) = self.type_parameters.as_ref() { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } } } @@ -2762,28 +2787,28 @@ impl<'a> Gen for TSTypeParameterDeclaration<'a> { impl<'a> Gen for TSTypeAnnotation<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); } } impl<'a> Gen for TSType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::TSFunctionType(ty) => ty.gen(p, ctx), - Self::TSConstructorType(ty) => ty.gen(p, ctx), - Self::TSArrayType(ty) => ty.gen(p, ctx), - Self::TSTupleType(ty) => ty.gen(p, ctx), - Self::TSUnionType(ty) => ty.gen(p, ctx), - Self::TSParenthesizedType(ty) => ty.gen(p, ctx), - Self::TSIntersectionType(ty) => ty.gen(p, ctx), - Self::TSConditionalType(ty) => ty.gen(p, ctx), - Self::TSInferType(ty) => ty.gen(p, ctx), - Self::TSIndexedAccessType(ty) => ty.gen(p, ctx), - Self::TSMappedType(ty) => ty.gen(p, ctx), - Self::TSNamedTupleMember(ty) => ty.gen(p, ctx), - Self::TSLiteralType(ty) => ty.literal.gen(p, ctx), - Self::TSImportType(ty) => ty.gen(p, ctx), - Self::TSQualifiedName(ty) => ty.gen(p, ctx), + Self::TSFunctionType(ty) => ty.print(p, ctx), + Self::TSConstructorType(ty) => ty.print(p, ctx), + Self::TSArrayType(ty) => ty.print(p, ctx), + Self::TSTupleType(ty) => ty.print(p, ctx), + Self::TSUnionType(ty) => ty.print(p, ctx), + Self::TSParenthesizedType(ty) => ty.print(p, ctx), + Self::TSIntersectionType(ty) => ty.print(p, ctx), + Self::TSConditionalType(ty) => ty.print(p, ctx), + Self::TSInferType(ty) => ty.print(p, ctx), + Self::TSIndexedAccessType(ty) => ty.print(p, ctx), + Self::TSMappedType(ty) => ty.print(p, ctx), + Self::TSNamedTupleMember(ty) => ty.print(p, ctx), + Self::TSLiteralType(ty) => ty.literal.print(p, ctx), + Self::TSImportType(ty) => ty.print(p, ctx), + Self::TSQualifiedName(ty) => ty.print(p, ctx), Self::TSAnyKeyword(_) => p.print_str("any"), Self::TSBigIntKeyword(_) => p.print_str("bigint"), Self::TSBooleanKeyword(_) => p.print_str("boolean"), @@ -2798,14 +2823,14 @@ impl<'a> Gen for TSType<'a> { Self::TSUndefinedKeyword(_) => p.print_str("undefined"), Self::TSUnknownKeyword(_) => p.print_str("unknown"), Self::TSVoidKeyword(_) => p.print_str("void"), - Self::TSTemplateLiteralType(ty) => ty.gen(p, ctx), - Self::TSTypeLiteral(ty) => ty.gen(p, ctx), - Self::TSTypeOperatorType(ty) => ty.gen(p, ctx), - Self::TSTypePredicate(ty) => ty.gen(p, ctx), - Self::TSTypeQuery(ty) => ty.gen(p, ctx), - Self::TSTypeReference(ty) => ty.gen(p, ctx), - Self::JSDocNullableType(ty) => ty.gen(p, ctx), - Self::JSDocNonNullableType(ty) => ty.gen(p, ctx), + Self::TSTemplateLiteralType(ty) => ty.print(p, ctx), + Self::TSTypeLiteral(ty) => ty.print(p, ctx), + Self::TSTypeOperatorType(ty) => ty.print(p, ctx), + Self::TSTypePredicate(ty) => ty.print(p, ctx), + Self::TSTypeQuery(ty) => ty.print(p, ctx), + Self::TSTypeReference(ty) => ty.print(p, ctx), + Self::JSDocNullableType(ty) => ty.print(p, ctx), + Self::JSDocNonNullableType(ty) => ty.print(p, ctx), Self::JSDocUnknownType(_ty) => p.print_str("unknown"), } } @@ -2813,7 +2838,7 @@ impl<'a> Gen for TSType<'a> { impl<'a> Gen for TSArrayType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.element_type.gen(p, ctx); + self.element_type.print(p, ctx); p.print_str("[]"); } } @@ -2829,7 +2854,7 @@ impl<'a> Gen for TSTupleType<'a> { impl<'a> Gen for TSUnionType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { if self.types.len() == 1 { - self.types[0].gen(p, ctx); + self.types[0].print(p, ctx); return; } for (index, item) in self.types.iter().enumerate() { @@ -2838,7 +2863,7 @@ impl<'a> Gen for TSUnionType<'a> { p.print_str("|"); p.print_soft_space(); } - item.gen(p, ctx); + item.print(p, ctx); } } } @@ -2846,7 +2871,7 @@ impl<'a> Gen for TSUnionType<'a> { impl<'a> Gen for TSParenthesizedType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_char(b'('); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); p.print_char(b')'); } } @@ -2854,7 +2879,7 @@ impl<'a> Gen for TSParenthesizedType<'a> { impl<'a> Gen for TSIntersectionType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { if self.types.len() == 1 { - self.types[0].gen(p, ctx); + self.types[0].print(p, ctx); return; } for (index, item) in self.types.iter().enumerate() { @@ -2863,35 +2888,35 @@ impl<'a> Gen for TSIntersectionType<'a> { p.print_str("&"); p.print_soft_space(); } - item.gen(p, ctx); + item.print(p, ctx); } } } impl<'a> Gen for TSConditionalType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.check_type.gen(p, ctx); + self.check_type.print(p, ctx); p.print_str(" extends "); - self.extends_type.gen(p, ctx); + self.extends_type.print(p, ctx); p.print_str(" ? "); - self.true_type.gen(p, ctx); + self.true_type.print(p, ctx); p.print_str(" : "); - self.false_type.gen(p, ctx); + self.false_type.print(p, ctx); } } impl<'a> Gen for TSInferType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_str("infer "); - self.type_parameter.gen(p, ctx); + self.type_parameter.print(p, ctx); } } impl<'a> Gen for TSIndexedAccessType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.object_type.gen(p, ctx); + self.object_type.print(p, ctx); p.print_str("["); - self.index_type.gen(p, ctx); + self.index_type.print(p, ctx); p.print_str("]"); } } @@ -2913,18 +2938,18 @@ impl<'a> Gen for TSMappedType<'a> { } p.print_hard_space(); p.print_str("["); - self.type_parameter.name.gen(p, ctx); + self.type_parameter.name.print(p, ctx); if let Some(constraint) = &self.type_parameter.constraint { p.print_str(" in "); - constraint.gen(p, ctx); + constraint.print(p, ctx); } if let Some(default) = &self.type_parameter.default { p.print_str(" = "); - default.gen(p, ctx); + default.print(p, ctx); } if let Some(name_type) = &self.name_type { p.print_str(" as "); - name_type.gen(p, ctx); + name_type.print(p, ctx); } p.print_str("]"); match self.optional { @@ -2943,7 +2968,7 @@ impl<'a> Gen for TSMappedType<'a> { if let Some(type_annotation) = &self.type_annotation { p.print_str(":"); p.print_soft_space(); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } p.print_str("}"); } @@ -2951,9 +2976,9 @@ impl<'a> Gen for TSMappedType<'a> { impl<'a> Gen for TSQualifiedName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.left.gen(p, ctx); + self.left.print(p, ctx); p.print_str("."); - self.right.gen(p, ctx); + self.right.print(p, ctx); } } @@ -2970,7 +2995,7 @@ impl<'a> Gen for TSTypeOperator<'a> { p.print_str("readonly "); } } - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); } } @@ -2981,7 +3006,7 @@ impl<'a> Gen for TSTypePredicate<'a> { } match &self.parameter_name { TSTypePredicateName::Identifier(ident) => { - ident.gen(p, ctx); + ident.print(p, ctx); } TSTypePredicateName::This(_ident) => { p.print_str("this"); @@ -2989,16 +3014,16 @@ impl<'a> Gen for TSTypePredicate<'a> { } if let Some(type_annotation) = &self.type_annotation { p.print_str(" is "); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } } } impl<'a> Gen for TSTypeReference<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.type_name.gen(p, ctx); + self.type_name.print(p, ctx); if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } } } @@ -3006,11 +3031,11 @@ impl<'a> Gen for TSTypeReference<'a> { impl<'a> Gen for JSDocNullableType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { if self.postfix { - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); p.print_str("?"); } else { p.print_str("?"); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); } } } @@ -3018,11 +3043,11 @@ impl<'a> Gen for JSDocNullableType<'a> { impl<'a> Gen for JSDocNonNullableType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { if self.postfix { - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); p.print_str("!"); } else { p.print_str("!"); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); } } } @@ -3034,7 +3059,7 @@ impl<'a> Gen for TSTemplateLiteralType<'a> { if index != 0 { if let Some(types) = self.types.get(index - 1) { p.print_str("${"); - types.gen(p, ctx); + types.print(p, ctx); p.print_str("}"); } } @@ -3050,7 +3075,7 @@ impl<'a> Gen for TSTypeLiteral<'a> { p.print_curly_braces(self.span, single_line, |p| { for item in &self.members { p.print_indent(); - item.gen(p, ctx); + item.print(p, ctx); if !single_line { p.print_semicolon(); p.print_soft_newline(); @@ -3064,12 +3089,12 @@ impl<'a> Gen for TSTypeName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { Self::IdentifierReference(ident) => { - ident.gen(p, ctx); + ident.print(p, ctx); } Self::QualifiedName(decl) => { - decl.left.gen(p, ctx); + decl.left.print(p, ctx); p.print_str("."); - decl.right.gen(p, ctx); + decl.right.print(p, ctx); } } } @@ -3078,14 +3103,14 @@ impl<'a> Gen for TSTypeName<'a> { impl<'a> Gen for TSLiteral<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::BooleanLiteral(decl) => decl.gen(p, ctx), - Self::NullLiteral(decl) => decl.gen(p, ctx), - Self::NumericLiteral(decl) => decl.gen(p, ctx), - Self::BigIntLiteral(decl) => decl.gen(p, ctx), - Self::RegExpLiteral(decl) => decl.gen(p, ctx), - Self::StringLiteral(decl) => decl.gen(p, ctx), - Self::TemplateLiteral(decl) => decl.gen(p, ctx), - Self::UnaryExpression(decl) => decl.gen_expr(p, Precedence::Comma, ctx), + Self::BooleanLiteral(decl) => decl.print(p, ctx), + Self::NullLiteral(decl) => decl.print(p, ctx), + Self::NumericLiteral(decl) => decl.print(p, ctx), + Self::BigIntLiteral(decl) => decl.print(p, ctx), + Self::RegExpLiteral(decl) => decl.print(p, ctx), + Self::StringLiteral(decl) => decl.print(p, ctx), + Self::TemplateLiteral(decl) => decl.print(p, ctx), + Self::UnaryExpression(decl) => decl.print_expr(p, Precedence::Comma, ctx), } } } @@ -3095,14 +3120,14 @@ impl<'a> Gen for TSTypeParameter<'a> { if self.r#const { p.print_str("const "); } - self.name.gen(p, ctx); + self.name.print(p, ctx); if let Some(constraint) = &self.constraint { p.print_str(" extends "); - constraint.gen(p, ctx); + constraint.print(p, ctx); } if let Some(default) = &self.default { p.print_str(" = "); - default.gen(p, ctx); + default.print(p, ctx); } } } @@ -3110,22 +3135,22 @@ impl<'a> Gen for TSTypeParameter<'a> { impl<'a> Gen for TSFunctionType<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_str("("); if let Some(this_param) = &self.this_param { - this_param.gen(p, ctx); + this_param.print(p, ctx); if !self.params.is_empty() || self.params.rest.is_some() { p.print_str(","); } p.print_soft_space(); } - self.params.gen(p, ctx); + self.params.print(p, ctx); p.print_str(")"); p.print_soft_space(); p.print_str("=>"); p.print_soft_space(); - self.return_type.gen(p, ctx); + self.return_type.print(p, ctx); } } @@ -3134,7 +3159,7 @@ impl<'a> Gen for TSThisParameter<'a> { p.print_str("this"); if let Some(type_annotation) = &self.type_annotation { p.print_str(": "); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } } } @@ -3142,25 +3167,25 @@ impl<'a> Gen for TSThisParameter<'a> { impl<'a> Gen for TSSignature<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::TSIndexSignature(signature) => signature.gen(p, ctx), + Self::TSIndexSignature(signature) => signature.print(p, ctx), Self::TSPropertySignature(signature) => { if signature.readonly { p.print_str("readonly "); } if signature.computed { p.print_char(b'['); - signature.key.gen(p, ctx); + signature.key.print(p, ctx); p.print_char(b']'); } else { match &signature.key { PropertyKey::StaticIdentifier(key) => { - key.gen(p, ctx); + key.print(p, ctx); } PropertyKey::PrivateIdentifier(key) => { p.print_str(key.name.as_str()); } key @ match_expression!(PropertyKey) => { - key.to_expression().gen_expr(p, Precedence::Comma, ctx); + key.to_expression().print_expr(p, Precedence::Comma, ctx); } } } @@ -3170,41 +3195,41 @@ impl<'a> Gen for TSSignature<'a> { if let Some(type_annotation) = &signature.type_annotation { p.print_colon(); p.print_soft_space(); - type_annotation.gen(p, ctx); + type_annotation.print(p, ctx); } } Self::TSCallSignatureDeclaration(signature) => { if let Some(type_parameters) = signature.type_parameters.as_ref() { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_str("("); if let Some(this_param) = &signature.this_param { - this_param.gen(p, ctx); + this_param.print(p, ctx); if !signature.params.is_empty() || signature.params.rest.is_some() { p.print_str(","); } p.print_soft_space(); } - signature.params.gen(p, ctx); + signature.params.print(p, ctx); p.print_str(")"); if let Some(return_type) = &signature.return_type { p.print_colon(); p.print_soft_space(); - return_type.gen(p, ctx); + return_type.print(p, ctx); } } Self::TSConstructSignatureDeclaration(signature) => { p.print_str("new "); if let Some(type_parameters) = signature.type_parameters.as_ref() { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_str("("); - signature.params.gen(p, ctx); + signature.params.print(p, ctx); p.print_str(")"); if let Some(return_type) = &signature.return_type { p.print_colon(); p.print_soft_space(); - return_type.gen(p, ctx); + return_type.print(p, ctx); } } Self::TSMethodSignature(signature) => { @@ -3215,18 +3240,18 @@ impl<'a> Gen for TSSignature<'a> { } if signature.computed { p.print_char(b'['); - signature.key.gen(p, ctx); + signature.key.print(p, ctx); p.print_char(b']'); } else { match &signature.key { PropertyKey::StaticIdentifier(key) => { - key.gen(p, ctx); + key.print(p, ctx); } PropertyKey::PrivateIdentifier(key) => { p.print_str(key.name.as_str()); } key @ match_expression!(PropertyKey) => { - key.to_expression().gen_expr(p, Precedence::Comma, ctx); + key.to_expression().print_expr(p, Precedence::Comma, ctx); } } } @@ -3234,22 +3259,22 @@ impl<'a> Gen for TSSignature<'a> { p.print_str("?"); } if let Some(type_parameters) = &signature.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_str("("); if let Some(this_param) = &signature.this_param { - this_param.gen(p, ctx); + this_param.print(p, ctx); if !signature.params.is_empty() || signature.params.rest.is_some() { p.print_str(","); } p.print_soft_space(); } - signature.params.gen(p, ctx); + signature.params.print(p, ctx); p.print_str(")"); if let Some(return_type) = &signature.return_type { p.print_colon(); p.print_soft_space(); - return_type.gen(p, ctx); + return_type.print(p, ctx); } } } @@ -3259,9 +3284,9 @@ impl<'a> Gen for TSSignature<'a> { impl<'a> Gen for TSTypeQuery<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_str("typeof "); - self.expr_name.gen(p, ctx); + self.expr_name.print(p, ctx); if let Some(type_params) = &self.type_parameters { - type_params.gen(p, ctx); + type_params.print(p, ctx); } } } @@ -3269,8 +3294,8 @@ impl<'a> Gen for TSTypeQuery<'a> { impl<'a> Gen for TSTypeQueryExprName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx), - Self::TSImportType(decl) => decl.gen(p, ctx), + match_ts_type_name!(Self) => self.to_ts_type_name().print(p, ctx), + Self::TSImportType(decl) => decl.print(p, ctx), } } } @@ -3281,18 +3306,18 @@ impl<'a> Gen for TSImportType<'a> { p.print_str("typeof "); } p.print_str("import("); - self.parameter.gen(p, ctx); + self.parameter.print(p, ctx); if let Some(attributes) = &self.attributes { p.print_str(", "); - attributes.gen(p, ctx); + attributes.print(p, ctx); } p.print_str(")"); if let Some(qualifier) = &self.qualifier { p.print_char(b'.'); - qualifier.gen(p, ctx); + qualifier.print(p, ctx); } if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } } } @@ -3301,7 +3326,7 @@ impl<'a> Gen for TSImportAttributes<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_char(b'{'); p.print_soft_space(); - self.attributes_keyword.gen(p, ctx); + self.attributes_keyword.print(p, ctx); p.print_str(":"); p.print_soft_space(); p.print_char(b'{'); @@ -3316,17 +3341,17 @@ impl<'a> Gen for TSImportAttributes<'a> { impl<'a> Gen for TSImportAttribute<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.name.gen(p, ctx); + self.name.print(p, ctx); p.print_str(": "); - self.value.gen_expr(p, Precedence::Member, ctx); + self.value.print_expr(p, Precedence::Member, ctx); } } impl<'a> Gen for TSImportAttributeName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - TSImportAttributeName::Identifier(ident) => ident.gen(p, ctx), - TSImportAttributeName::StringLiteral(literal) => literal.gen(p, ctx), + TSImportAttributeName::Identifier(ident) => ident.print(p, ctx), + TSImportAttributeName::StringLiteral(literal) => literal.print(p, ctx), } } } @@ -3352,26 +3377,26 @@ impl<'a> Gen for TSIndexSignature<'a> { p.print_str(parameter.name.as_str()); p.print_colon(); p.print_soft_space(); - parameter.type_annotation.gen(p, ctx); + parameter.type_annotation.print(p, ctx); } p.print_str("]"); p.print_colon(); p.print_soft_space(); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); } } impl<'a> Gen for TSTupleElement<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - match_ts_type!(TSTupleElement) => self.to_ts_type().gen(p, ctx), + match_ts_type!(TSTupleElement) => self.to_ts_type().print(p, ctx), TSTupleElement::TSOptionalType(ts_type) => { - ts_type.type_annotation.gen(p, ctx); + ts_type.type_annotation.print(p, ctx); p.print_str("?"); } TSTupleElement::TSRestType(ts_type) => { p.print_str("..."); - ts_type.type_annotation.gen(p, ctx); + ts_type.type_annotation.print(p, ctx); } } } @@ -3379,13 +3404,13 @@ impl<'a> Gen for TSTupleElement<'a> { impl<'a> Gen for TSNamedTupleMember<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.label.gen(p, ctx); + self.label.print(p, ctx); if self.optional { p.print_str("?"); } p.print_str(":"); p.print_soft_space(); - self.element_type.gen(p, ctx); + self.element_type.print(p, ctx); } } @@ -3398,7 +3423,7 @@ impl<'a> Gen for TSModuleDeclaration<'a> { // If the kind is global, then the id is also `global`, so we don't need to print it if !self.kind.is_global() { p.print_space_before_identifier(); - self.id.gen(p, ctx); + self.id.print(p, ctx); } if let Some(body) = &self.body { @@ -3407,7 +3432,7 @@ impl<'a> Gen for TSModuleDeclaration<'a> { match body { TSModuleDeclarationBody::TSModuleDeclaration(b) => { p.print_char(b'.'); - b.id.gen(p, ctx); + b.id.print(p, ctx); if let Some(b) = &b.body { body = b; } else { @@ -3416,7 +3441,7 @@ impl<'a> Gen for TSModuleDeclaration<'a> { } TSModuleDeclarationBody::TSModuleBlock(body) => { p.print_soft_space(); - body.gen(p, ctx); + body.print(p, ctx); break; } } @@ -3429,8 +3454,8 @@ impl<'a> Gen for TSModuleDeclaration<'a> { impl<'a> Gen for TSModuleDeclarationName<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match self { - Self::Identifier(ident) => ident.gen(p, ctx), - Self::StringLiteral(s) => s.gen(p, ctx), + Self::Identifier(ident) => ident.print(p, ctx), + Self::StringLiteral(s) => s.print(p, ctx), } } } @@ -3440,11 +3465,11 @@ impl<'a> Gen for TSModuleBlock<'a> { let is_empty = self.directives.is_empty() && self.body.is_empty(); p.print_curly_braces(self.span, is_empty, |p| { for directive in &self.directives { - directive.gen(p, ctx); + directive.print(p, ctx); } for stmt in &self.body { p.print_semicolon_if_needed(); - stmt.gen(p, ctx); + stmt.print(p, ctx); } }); p.needs_semicolon = false; @@ -3458,14 +3483,14 @@ impl<'a> Gen for TSTypeAliasDeclaration<'a> { } p.print_str("type"); p.print_space_before_identifier(); - self.id.gen(p, ctx); + self.id.print(p, ctx); if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_soft_space(); p.print_str("="); p.print_soft_space(); - self.type_annotation.gen(p, ctx); + self.type_annotation.print(p, ctx); } } @@ -3473,9 +3498,9 @@ impl<'a> Gen for TSInterfaceDeclaration<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_str("interface"); p.print_hard_space(); - self.id.gen(p, ctx); + self.id.print(p, ctx); if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } if let Some(extends) = &self.extends { if !extends.is_empty() { @@ -3487,7 +3512,7 @@ impl<'a> Gen for TSInterfaceDeclaration<'a> { p.print_curly_braces(self.body.span, self.body.body.is_empty(), |p| { for item in &self.body.body { p.print_indent(); - item.gen(p, ctx); + item.print(p, ctx); p.print_semicolon(); p.print_soft_newline(); } @@ -3497,9 +3522,9 @@ impl<'a> Gen for TSInterfaceDeclaration<'a> { impl<'a> Gen for TSInterfaceHeritage<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { - self.expression.gen_expr(p, Precedence::Call, ctx); + self.expression.print_expr(p, Precedence::Call, ctx); if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } } } @@ -3515,12 +3540,12 @@ impl<'a> Gen for TSEnumDeclaration<'a> { } p.print_space_before_identifier(); p.print_str("enum "); - self.id.gen(p, ctx); + self.id.print(p, ctx); p.print_space_before_identifier(); p.print_curly_braces(self.span, self.members.is_empty(), |p| { for member in &self.members { p.print_indent(); - member.gen(p, ctx); + member.print(p, ctx); p.print_comma(); p.print_soft_newline(); } @@ -3531,13 +3556,13 @@ impl<'a> Gen for TSEnumDeclaration<'a> { impl<'a> Gen for TSEnumMember<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { match &self.id { - TSEnumMemberName::StaticIdentifier(decl) => decl.gen(p, ctx), - TSEnumMemberName::StaticStringLiteral(decl) => decl.gen(p, ctx), - TSEnumMemberName::StaticTemplateLiteral(decl) => decl.gen(p, ctx), - TSEnumMemberName::StaticNumericLiteral(decl) => decl.gen(p, ctx), + TSEnumMemberName::StaticIdentifier(decl) => decl.print(p, ctx), + TSEnumMemberName::StaticStringLiteral(decl) => decl.print(p, ctx), + TSEnumMemberName::StaticTemplateLiteral(decl) => decl.print(p, ctx), + TSEnumMemberName::StaticNumericLiteral(decl) => decl.print(p, ctx), decl @ match_expression!(TSEnumMemberName) => { p.print_str("["); - decl.to_expression().gen_expr(p, Precedence::Lowest, ctx); + decl.to_expression().print_expr(p, Precedence::Lowest, ctx); p.print_str("]"); } } @@ -3545,7 +3570,7 @@ impl<'a> Gen for TSEnumMember<'a> { p.print_soft_space(); p.print_equal(); p.print_soft_space(); - init.gen_expr(p, Precedence::Lowest, ctx); + init.print_expr(p, Precedence::Lowest, ctx); } } } @@ -3557,24 +3582,24 @@ impl<'a> Gen for TSConstructorType<'a> { } p.print_str("new "); if let Some(type_parameters) = &self.type_parameters { - type_parameters.gen(p, ctx); + type_parameters.print(p, ctx); } p.print_str("("); - self.params.gen(p, ctx); + self.params.print(p, ctx); p.print_str(")"); p.print_soft_space(); p.print_str("=>"); p.print_soft_space(); - self.return_type.gen(p, ctx); + self.return_type.print(p, ctx); } } impl<'a> Gen for TSImportEqualsDeclaration<'a> { fn gen(&self, p: &mut Codegen, ctx: Context) { p.print_str("import "); - self.id.gen(p, ctx); + self.id.print(p, ctx); p.print_str(" = "); - self.module_reference.gen(p, ctx); + self.module_reference.print(p, ctx); } } @@ -3583,10 +3608,10 @@ impl<'a> Gen for TSModuleReference<'a> { match self { Self::ExternalModuleReference(decl) => { p.print_str("require("); - decl.expression.gen(p, ctx); + decl.expression.print(p, ctx); p.print_str(")"); } - match_ts_type_name!(Self) => self.to_ts_type_name().gen(p, ctx), + match_ts_type_name!(Self) => self.to_ts_type_name().print(p, ctx), } } } diff --git a/crates/oxc_codegen/src/lib.rs b/crates/oxc_codegen/src/lib.rs index c2516e0a14d2c..a0272d82b9db5 100644 --- a/crates/oxc_codegen/src/lib.rs +++ b/crates/oxc_codegen/src/lib.rs @@ -66,6 +66,7 @@ pub struct Codegen<'a> { source_text: Option<&'a str>, trivias: Trivias, + leading_comments: FxHashMap>, mangler: Option, @@ -133,6 +134,7 @@ impl<'a> Codegen<'a> { comment_options: CommentOptions::default(), source_text: None, trivias: Trivias::default(), + leading_comments: FxHashMap::default(), mangler: None, code: vec![], needs_semicolon: false, @@ -185,6 +187,20 @@ impl<'a> Codegen<'a> { trivias: Trivias, options: CommentOptions, ) -> Self { + let mut leading_comments: FxHashMap> = FxHashMap::default(); + for comment in trivias + .comments() + .copied() + .filter(|comment| comment.attached_to != 0 && comment.is_leading()) + .filter(|comment| { + let s = comment.span.source_text(source_text); + // only print jsdoc and `@__PURE__`, `@license`, `@preserve` etc + (comment.is_multi_line() && s.starts_with('*')) || s.trim_start().starts_with('@') + }) + { + leading_comments.entry(comment.attached_to).or_default().push(comment); + } + self.leading_comments = leading_comments; self.trivias = trivias; self.comment_options = options; self.with_source_text(source_text) @@ -206,7 +222,7 @@ impl<'a> Codegen<'a> { #[must_use] pub fn build(mut self, program: &Program<'_>) -> CodegenReturn { - program.gen(&mut self, Context::default()); + program.print(&mut self, Context::default()); let source_text = self.into_source_text(); let source_map = self.sourcemap_builder.map(SourcemapBuilder::into_sourcemap); CodegenReturn { source_text, source_map } @@ -233,7 +249,7 @@ impl<'a> Codegen<'a> { #[inline] pub fn print_expression(&mut self, expr: &Expression<'_>) { - expr.gen_expr(self, Precedence::Lowest, Context::empty()); + expr.print_expr(self, Precedence::Lowest, Context::empty()); } } @@ -353,7 +369,7 @@ impl<'a> Codegen<'a> { fn print_sequence(&mut self, items: &[T], ctx: Context) { for item in items { - item.gen(self, ctx); + item.print(self, ctx); self.print_comma(); } } @@ -371,6 +387,7 @@ impl<'a> Codegen<'a> { self.print_indent(); } self.add_source_mapping(span.end); + self.print_leading_comments(span.end); self.print_char(b'}'); } @@ -404,7 +421,7 @@ impl<'a> Codegen<'a> { self.print_hard_space(); } self.print_next_indent_as_space = true; - stmt.gen(self, ctx); + stmt.print(self, ctx); } } } @@ -413,7 +430,7 @@ impl<'a> Codegen<'a> { self.print_curly_braces(stmt.span, stmt.body.is_empty(), |p| { for stmt in &stmt.body { p.print_semicolon_if_needed(); - stmt.gen(p, ctx); + stmt.print(p, ctx); } }); self.needs_semicolon = false; @@ -423,11 +440,11 @@ impl<'a> Codegen<'a> { // ``` // let mut iter = items.iter(); // let Some(item) = iter.next() else { return }; - // item.gen(self, ctx); + // item.print(self, ctx); // for item in iter { // self.print_comma(); // self.print_soft_space(); - // item.gen(self, ctx); + // item.print(self, ctx); // } // ``` // But it turned out this was actually a bit slower. @@ -438,7 +455,7 @@ impl<'a> Codegen<'a> { self.print_comma(); self.print_soft_space(); } - item.gen(self, ctx); + item.print(self, ctx); } } @@ -448,7 +465,7 @@ impl<'a> Codegen<'a> { self.print_comma(); self.print_soft_space(); } - item.gen_expr(self, precedence, ctx); + item.print_expr(self, precedence, ctx); } } @@ -590,4 +607,27 @@ impl<'a> Codegen<'a> { fn try_take_moved_comment(&mut self, node_start: u32) -> Option> { self.move_comment_map.remove(&node_start) } + + fn print_leading_comments(&mut self, start: u32) { + if self.options.minify { + return; + } + let Some(source_text) = self.source_text else { return }; + let Some(comments) = self.leading_comments.remove(&start) else { return }; + // dbg!(&comments); + + let first = comments.first().copied().unwrap(); + let last = comments.last().copied().unwrap(); + + let s = Span::new(first.real_span_start(), last.real_span_end()).source_text(source_text); + if matches!(first.preceded_by_newline, Some(true)) { + self.print_char(b'\n'); + self.print_indent(); + } + self.print_str(s); + if last.is_single_line() || matches!(last.followed_by_newline, Some(true)) { + self.print_char(b'\n'); + self.print_indent(); + } + } } diff --git a/crates/oxc_parser/examples/parser.rs b/crates/oxc_parser/examples/parser.rs index fe3f863988168..d28e570ed798b 100644 --- a/crates/oxc_parser/examples/parser.rs +++ b/crates/oxc_parser/examples/parser.rs @@ -36,7 +36,7 @@ fn main() -> Result<(), String> { println!("Comments:"); for comment in ret.trivias.comments() { let s = comment.real_span().source_text(&source_text); - println!("{s}"); + println!("{comment:?} {s}"); } } diff --git a/crates/oxc_parser/src/lexer/mod.rs b/crates/oxc_parser/src/lexer/mod.rs index 307f7287c04af..fb3a048624b4c 100644 --- a/crates/oxc_parser/src/lexer/mod.rs +++ b/crates/oxc_parser/src/lexer/mod.rs @@ -210,6 +210,7 @@ impl<'a> Lexer<'a> { return lookahead.token; } let kind = self.read_next_token(); + self.trivia_builder.handle_token(self.token.start); self.finish_next(kind) } @@ -218,6 +219,7 @@ impl<'a> Lexer<'a> { self.token.end = self.offset(); debug_assert!(self.token.start <= self.token.end); let token = self.token; + self.trivia_builder.handle_token(token.start); self.token = Token::default(); token } diff --git a/crates/oxc_parser/src/lexer/trivia_builder.rs b/crates/oxc_parser/src/lexer/trivia_builder.rs index 1e6ed86543176..ffcc35a664fb9 100644 --- a/crates/oxc_parser/src/lexer/trivia_builder.rs +++ b/crates/oxc_parser/src/lexer/trivia_builder.rs @@ -1,13 +1,25 @@ -use oxc_ast::{Comment, CommentKind, Trivias}; +use oxc_ast::{Comment, CommentKind, CommentPosition, Trivias}; use oxc_span::Span; -#[derive(Debug, Default)] +#[derive(Debug)] pub struct TriviaBuilder { // NOTE(lucab): This is a set of unique comments. Duplicated // comments could be generated in case of rewind; they are // filtered out at insertion time. pub(crate) comments: Vec, + irregular_whitespaces: Vec, + + // index of processed comments + processed: usize, + + saw_newline: bool, +} + +impl Default for TriviaBuilder { + fn default() -> Self { + Self { comments: vec![], irregular_whitespaces: vec![], processed: 0, saw_newline: true } + } } impl TriviaBuilder { @@ -25,6 +37,39 @@ impl TriviaBuilder { self.add_comment(Comment::new(start + 2, end - 2, CommentKind::MultiLine)); } + pub fn handle_newline(&mut self) { + if let Some(c) = self.comments.last_mut() { + if c.followed_by_newline.is_none() { + c.followed_by_newline.replace(true); + } + } + if !self.saw_newline { + if let Some(comments) = self.comments.get_mut(self.processed..) { + for comment in comments { + comment.position = CommentPosition::Trailing; + } + self.processed = self.comments.len(); + } + } + self.saw_newline = true; + } + + pub fn handle_token(&mut self, attached_to: u32) { + if let Some(c) = self.comments.last_mut() { + if c.followed_by_newline.is_none() { + c.followed_by_newline.replace(false); + } + } + if let Some(comments) = self.comments.get_mut(self.processed..) { + for comment in comments { + comment.position = CommentPosition::Leading; + comment.attached_to = attached_to; + } + self.processed = self.comments.len(); + } + self.saw_newline = false; + } + fn add_comment(&mut self, comment: Comment) { // The comments array is an ordered vec, only add the comment if its not added before, // to avoid situations where the parser needs to rewind and tries to reinsert the comment. @@ -33,6 +78,22 @@ impl TriviaBuilder { return; } } + + let mut comment = comment; + if comment.kind.is_single_line() && !self.saw_newline { + comment.position = CommentPosition::Trailing; + if let Some(comments) = self.comments.get_mut(self.processed..) { + for comment in comments { + comment.position = CommentPosition::Trailing; + } + self.processed = self.comments.len() + 1; // +1 for the newly added comment below. + } + self.saw_newline = true; + } + if self.saw_newline { + comment.preceded_by_newline.replace(true); + } + self.comments.push(comment); } diff --git a/crates/oxc_parser/src/lexer/unicode.rs b/crates/oxc_parser/src/lexer/unicode.rs index d67508ec7bde5..2e223b98abaab 100644 --- a/crates/oxc_parser/src/lexer/unicode.rs +++ b/crates/oxc_parser/src/lexer/unicode.rs @@ -34,6 +34,7 @@ impl<'a> Lexer<'a> { c if is_irregular_line_terminator(c) => { self.consume_char(); self.token.is_on_new_line = true; + self.trivia_builder.handle_newline(); self.trivia_builder.add_irregular_whitespace(self.token.start, self.offset()); Kind::Skip } diff --git a/crates/oxc_parser/src/lexer/whitespace.rs b/crates/oxc_parser/src/lexer/whitespace.rs index 577c12aec2bb3..c6e8403e25b59 100644 --- a/crates/oxc_parser/src/lexer/whitespace.rs +++ b/crates/oxc_parser/src/lexer/whitespace.rs @@ -9,6 +9,7 @@ static NOT_REGULAR_WHITESPACE_OR_LINE_BREAK_TABLE: SafeByteMatchTable = impl<'a> Lexer<'a> { pub(super) fn line_break_handler(&mut self) -> Kind { self.token.is_on_new_line = true; + self.trivia_builder.handle_newline(); // Indentation is common after a line break. // Consume it, along with any further line breaks. diff --git a/tasks/coverage/codegen_sourcemap.snap b/tasks/coverage/codegen_sourcemap.snap index 2654e3c2bce86..2d068ae997355 100644 --- a/tasks/coverage/codegen_sourcemap.snap +++ b/tasks/coverage/codegen_sourcemap.snap @@ -640,4623 +640,4623 @@ Invalid Character `[` (84:1-89:0) "}\n\n/**\n * Keeps track of the current dispatcher.\n */" --> (60:2-61:2) "\t}\n\t" (89:0-89:4) "\nvar" --> (61:2-61:6) "\tvar" (89:4-89:29) " ReactCurrentDispatcher =" --> (61:6-61:31) " ReactCurrentDispatcher =" -(89:29-94:2) " {\n /**\n * @internal\n * @type {ReactComponent}\n */\n " --> (61:31-61:33) " {" -(94:2-94:11) " current:" --> (61:33-61:42) " current:" -(94:11-95:1) " null\n" --> (61:42-61:47) " null" -(95:1-101:0) "};\n\n/**\n * Keeps track of the current batch's configuration such as how long an update\n * should suspend for if it needs to.\n */" --> (61:47-62:2) " };\n\t" -(101:0-101:4) "\nvar" --> (62:2-62:6) "\tvar" -(101:4-101:30) " ReactCurrentBatchConfig =" --> (62:6-62:32) " ReactCurrentBatchConfig =" -(101:30-102:2) " {\n " --> (62:32-62:34) " {" -(102:2-102:14) " transition:" --> (62:34-62:46) " transition:" -(102:14-103:1) " 0\n" --> (62:46-62:48) " 0" -(103:1-111:0) "};\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n */" --> (62:48-63:2) " };\n\t" -(111:0-111:4) "\nvar" --> (63:2-63:6) "\tvar" -(111:4-111:24) " ReactCurrentOwner =" --> (63:6-63:26) " ReactCurrentOwner =" -(111:24-116:2) " {\n /**\n * @internal\n * @type {ReactComponent}\n */\n " --> (63:26-63:28) " {" -(116:2-116:11) " current:" --> (63:28-63:37) " current:" -(116:11-117:1) " null\n" --> (63:37-63:42) " null" -(117:1-119:0) "};\n" --> (63:42-64:2) " };\n\t" -(119:0-119:4) "\nvar" --> (64:2-64:6) "\tvar" -(119:4-119:29) " ReactDebugCurrentFrame =" --> (64:6-64:31) " ReactDebugCurrentFrame =" -(119:29-119:31) " {" --> (64:31-64:32) " " -(119:31-120:0) "};" --> (64:32-65:2) "{};\n\t" -(120:0-120:4) "\nvar" --> (65:2-65:6) "\tvar" -(120:4-120:29) " currentExtraStackFrame =" --> (65:6-65:31) " currentExtraStackFrame =" -(120:29-121:0) " null;" --> (65:31-66:2) " null;\n\t" -(121:0-121:9) "\nfunction" --> (66:2-66:11) "\tfunction" -(121:9-121:28) " setExtraStackFrame" --> (66:11-66:30) " setExtraStackFrame" -(121:28-121:35) "(stack)" --> (66:30-66:37) "(stack)" -(121:35-122:2) " {\n " --> (66:37-67:3) " {\n\t\t" -(122:2-123:4) " {\n " --> (67:3-68:0) "\t{" -(123:4-123:29) " currentExtraStackFrame =" --> (68:0-68:29) "\n\t\t\t\tcurrentExtraStackFrame =" -(123:29-124:3) " stack;\n " --> (68:29-69:3) " stack;\n\t\t" -(124:3-125:1) "}\n" --> (69:3-70:2) "\t}\n\t" -(125:1-127:0) "}\n" --> (70:2-71:2) "\t}\n\t" -(127:0-128:2) "\n{\n " --> (71:2-72:0) "\t{" -(128:2-128:25) " ReactDebugCurrentFrame" --> (72:0-72:26) "\n\t\t\tReactDebugCurrentFrame" -(128:25-128:46) ".setExtraStackFrame =" --> (72:26-72:47) ".setExtraStackFrame =" -(128:46-128:56) " function " --> (72:47-72:56) " function" -(128:56-128:63) "(stack)" --> (72:56-72:63) "(stack)" -(128:63-129:4) " {\n " --> (72:63-73:4) " {\n\t\t\t" -(129:4-130:6) " {\n " --> (73:4-74:0) "\t{" -(130:6-130:31) " currentExtraStackFrame =" --> (74:0-74:30) "\n\t\t\t\t\tcurrentExtraStackFrame =" -(130:31-131:5) " stack;\n " --> (74:30-75:4) " stack;\n\t\t\t" -(131:5-132:3) "}\n " --> (75:4-76:3) "\t}\n\t\t" -(132:3-135:2) "}; // Stack implementation injected by the current renderer.\n\n\n " --> (76:3-77:0) "\t};" -(135:2-135:25) " ReactDebugCurrentFrame" --> (77:0-77:26) "\n\t\t\tReactDebugCurrentFrame" -(135:25-135:43) ".getCurrentStack =" --> (77:26-77:44) ".getCurrentStack =" -(135:43-137:2) " null;\n\n " --> (77:44-78:0) " null;" -(137:2-137:25) " ReactDebugCurrentFrame" --> (78:0-78:26) "\n\t\t\tReactDebugCurrentFrame" -(137:25-137:44) ".getStackAddendum =" --> (78:26-78:45) ".getStackAddendum =" -(137:44-137:56) " function ()" --> (78:45-78:56) " function()" -(137:56-138:4) " {\n " --> (78:56-79:4) " {\n\t\t\t" -(138:4-138:8) " var" --> (79:4-79:8) "\tvar" -(138:8-138:16) " stack =" --> (79:8-79:16) " stack =" -(138:16-140:4) " ''; // Add an extra top frame while an element is being validated\n\n " --> (79:16-80:0) " \"\";" -(140:4-140:8) " if " --> (80:0-80:8) "\n\t\t\t\tif " -(140:8-140:32) "(currentExtraStackFrame)" --> (80:8-80:32) "(currentExtraStackFrame)" -(140:32-141:6) " {\n " --> (80:32-81:0) " {" -(141:6-141:15) " stack +=" --> (81:0-81:14) "\n\t\t\t\t\tstack +=" -(141:15-142:5) " currentExtraStackFrame;\n " --> (81:14-82:4) " currentExtraStackFrame;\n\t\t\t" -(142:5-145:4) "} // Delegate to the injected renderer-specific implementation\n\n\n " --> (82:4-83:4) "\t}\n\t\t\t" -(145:4-145:8) " var" --> (83:4-83:8) "\tvar" -(145:8-145:15) " impl =" --> (83:8-83:15) " impl =" -(145:15-145:38) " ReactDebugCurrentFrame" --> (83:15-83:38) " ReactDebugCurrentFrame" -(145:38-147:4) ".getCurrentStack;\n\n " --> (83:38-84:0) ".getCurrentStack;" -(147:4-147:8) " if " --> (84:0-84:8) "\n\t\t\t\tif " -(147:8-147:14) "(impl)" --> (84:8-84:14) "(impl)" -(147:14-148:6) " {\n " --> (84:14-85:0) " {" -(148:6-148:15) " stack +=" --> (85:0-85:14) "\n\t\t\t\t\tstack +=" -(148:15-148:21) " impl(" --> (85:14-85:20) " impl(" -(148:21-148:25) ") ||" --> (85:20-85:24) ") ||" -(148:25-149:5) " '';\n " --> (85:24-86:4) " \"\";\n\t\t\t" -(149:5-151:4) "}\n\n " --> (86:4-87:0) "\t}" -(151:4-151:11) " return" --> (87:0-87:11) "\n\t\t\t\treturn" -(151:11-152:3) " stack;\n " --> (87:11-88:3) " stack;\n\t\t" -(152:3-153:1) "};\n" --> (88:3-89:2) "\t};\n\t" -(153:1-158:0) "}\n\n/**\n * Used by act() to track whether you're inside an act() scope.\n */" --> (89:2-90:2) "\t}\n\t" -(158:0-158:4) "\nvar" --> (90:2-90:6) "\tvar" -(158:4-158:27) " IsSomeRendererActing =" --> (90:6-90:29) " IsSomeRendererActing =" -(158:27-159:2) " {\n " --> (90:29-90:31) " {" -(159:2-159:11) " current:" --> (90:31-90:40) " current:" -(159:11-160:1) " false\n" --> (90:40-90:46) " false" -(160:1-162:0) "};\n" --> (90:46-91:2) " };\n\t" -(162:0-162:4) "\nvar" --> (91:2-91:6) "\tvar" -(162:4-162:27) " ReactSharedInternals =" --> (91:6-91:29) " ReactSharedInternals =" -(162:27-163:26) " {\n ReactCurrentDispatcher:" --> (91:29-92:3) " {\n\t\t" -(163:26-164:27) " ReactCurrentDispatcher,\n ReactCurrentBatchConfig:" --> (92:3-93:3) "\tReactCurrentDispatcher,\n\t\t" -(164:27-165:21) " ReactCurrentBatchConfig,\n ReactCurrentOwner:" --> (93:3-94:3) "\tReactCurrentBatchConfig,\n\t\t" -(165:21-166:24) " ReactCurrentOwner,\n IsSomeRendererActing:" --> (94:3-95:3) "\tReactCurrentOwner,\n\t\t" -(166:24-168:2) " IsSomeRendererActing,\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\n " --> (95:3-96:3) "\tIsSomeRendererActing,\n\t\t" -(168:2-168:10) " assign:" --> (96:3-96:11) "\tassign:" -(168:10-169:1) " _assign\n" --> (96:11-97:2) " _assign\n\t" -(169:1-171:0) "};\n" --> (97:2-98:2) "\t};\n\t" -(171:0-172:2) "\n{\n " --> (98:2-99:0) "\t{" -(172:2-172:23) " ReactSharedInternals" --> (99:0-99:24) "\n\t\t\tReactSharedInternals" -(172:23-172:48) ".ReactDebugCurrentFrame =" --> (99:24-99:49) ".ReactDebugCurrentFrame =" -(172:48-173:1) " ReactDebugCurrentFrame;\n" --> (99:49-100:2) " ReactDebugCurrentFrame;\n\t" -(173:1-180:0) "}\n\n// by calls to these methods by a Babel plugin.\n//\n// In PROD (or in packages without access to React internals),\n// they are left as they are instead.\n" --> (100:2-101:2) "\t}\n\t" -(180:0-180:9) "\nfunction" --> (101:2-101:11) "\tfunction" -(180:9-180:14) " warn" --> (101:11-101:16) " warn" -(180:14-180:22) "(format)" --> (101:16-101:24) "(format)" -(180:22-181:2) " {\n " --> (101:24-102:3) " {\n\t\t" -(181:2-182:4) " {\n " --> (102:3-103:0) "\t{" -(182:4-182:9) " for " --> (103:0-103:9) "\n\t\t\t\tfor " -(182:9-182:13) "(var" --> (103:9-103:13) "(var" -(182:13-182:20) " _len =" --> (103:13-103:20) " _len =" -(182:20-182:30) " arguments" --> (103:20-103:30) " arguments" -(182:30-182:38) ".length," --> (103:30-103:38) ".length," -(182:38-182:45) " args =" --> (103:38-103:45) " args =" -(182:45-182:49) " new" --> (103:45-103:49) " new" -(182:49-182:55) " Array" --> (103:49-103:55) " Array" -(182:55-182:62) "(_len >" --> (103:55-103:62) "(_len >" -(182:62-182:66) " 1 ?" --> (103:62-103:66) " 1 ?" -(182:66-182:73) " _len -" --> (103:66-103:73) " _len -" -(182:73-182:77) " 1 :" --> (103:73-103:77) " 1 :" -(182:77-182:81) " 0)," --> (103:77-103:81) " 0)," -(182:81-182:88) " _key =" --> (103:81-103:88) " _key =" -(182:88-182:91) " 1;" --> (103:88-103:91) " 1;" -(182:91-182:98) " _key <" --> (103:91-103:98) " _key <" -(182:98-182:104) " _len;" --> (103:98-103:104) " _len;" -(182:104-182:112) " _key++)" --> (103:104-103:112) " _key++)" -(182:112-183:6) " {\n " --> (103:112-104:0) " {" -(183:6-183:11) " args" --> (104:0-104:10) "\n\t\t\t\t\targs" -(183:11-183:18) "[_key -" --> (104:10-104:17) "[_key -" -(183:18-183:23) " 1] =" --> (104:17-104:22) " 1] =" -(183:23-183:33) " arguments" --> (104:22-104:32) " arguments" -(183:33-184:5) "[_key];\n " --> (104:32-105:4) "[_key];\n\t\t\t" -(184:5-186:4) "}\n\n " --> (105:4-106:0) "\t}" -(186:4-186:17) " printWarning" --> (106:0-106:17) "\n\t\t\t\tprintWarning" -(186:17-186:25) "('warn'," --> (106:17-106:25) "(\"warn\"," -(186:25-186:33) " format," --> (106:25-106:33) " format," -(186:33-186:38) " args" --> (106:33-106:38) " args" -(186:38-187:3) ");\n " --> (106:38-107:3) ");\n\t\t" -(187:3-188:1) "}\n" --> (107:3-108:2) "\t}\n\t" -(188:1-189:0) "}" --> (108:2-109:2) "\t}\n\t" -(189:0-189:9) "\nfunction" --> (109:2-109:11) "\tfunction" -(189:9-189:15) " error" --> (109:11-109:17) " error" -(189:15-189:23) "(format)" --> (109:17-109:25) "(format)" -(189:23-190:2) " {\n " --> (109:25-110:3) " {\n\t\t" -(190:2-191:4) " {\n " --> (110:3-111:0) "\t{" -(191:4-191:9) " for " --> (111:0-111:9) "\n\t\t\t\tfor " -(191:9-191:13) "(var" --> (111:9-111:13) "(var" -(191:13-191:21) " _len2 =" --> (111:13-111:21) " _len2 =" -(191:21-191:31) " arguments" --> (111:21-111:31) " arguments" -(191:31-191:39) ".length," --> (111:31-111:39) ".length," -(191:39-191:46) " args =" --> (111:39-111:46) " args =" -(191:46-191:50) " new" --> (111:46-111:50) " new" -(191:50-191:56) " Array" --> (111:50-111:56) " Array" -(191:56-191:64) "(_len2 >" --> (111:56-111:64) "(_len2 >" -(191:64-191:68) " 1 ?" --> (111:64-111:68) " 1 ?" -(191:68-191:76) " _len2 -" --> (111:68-111:76) " _len2 -" -(191:76-191:80) " 1 :" --> (111:76-111:80) " 1 :" -(191:80-191:84) " 0)," --> (111:80-111:84) " 0)," -(191:84-191:92) " _key2 =" --> (111:84-111:92) " _key2 =" -(191:92-191:95) " 1;" --> (111:92-111:95) " 1;" -(191:95-191:103) " _key2 <" --> (111:95-111:103) " _key2 <" -(191:103-191:110) " _len2;" --> (111:103-111:110) " _len2;" -(191:110-191:119) " _key2++)" --> (111:110-111:119) " _key2++)" -(191:119-192:6) " {\n " --> (111:119-112:0) " {" -(192:6-192:11) " args" --> (112:0-112:10) "\n\t\t\t\t\targs" -(192:11-192:19) "[_key2 -" --> (112:10-112:18) "[_key2 -" -(192:19-192:24) " 1] =" --> (112:18-112:23) " 1] =" -(192:24-192:34) " arguments" --> (112:23-112:33) " arguments" -(192:34-193:5) "[_key2];\n " --> (112:33-113:4) "[_key2];\n\t\t\t" -(193:5-195:4) "}\n\n " --> (113:4-114:0) "\t}" -(195:4-195:17) " printWarning" --> (114:0-114:17) "\n\t\t\t\tprintWarning" -(195:17-195:26) "('error'," --> (114:17-114:26) "(\"error\"," -(195:26-195:34) " format," --> (114:26-114:34) " format," -(195:34-195:39) " args" --> (114:34-114:39) " args" -(195:39-196:3) ");\n " --> (114:39-115:3) ");\n\t\t" -(196:3-197:1) "}\n" --> (115:3-116:2) "\t}\n\t" -(197:1-199:0) "}\n" --> (116:2-117:2) "\t}\n\t" -(199:0-199:9) "\nfunction" --> (117:2-117:11) "\tfunction" -(199:9-199:22) " printWarning" --> (117:11-117:24) " printWarning" -(199:22-199:29) "(level," --> (117:24-117:31) "(level," -(199:29-199:37) " format," --> (117:31-117:39) " format," -(199:37-199:43) " args)" --> (117:39-117:45) " args)" -(199:43-202:2) " {\n // When changing this logic, you might want to also\n // update consoleWithStackDev.www.js as well.\n " --> (117:45-118:3) " {\n\t\t" -(202:2-203:4) " {\n " --> (118:3-119:4) "\t{\n\t\t\t" -(203:4-203:8) " var" --> (119:4-119:8) "\tvar" -(203:8-203:33) " ReactDebugCurrentFrame =" --> (119:8-119:33) " ReactDebugCurrentFrame =" -(203:33-203:54) " ReactSharedInternals" --> (119:33-119:54) " ReactSharedInternals" -(203:54-204:4) ".ReactDebugCurrentFrame;\n " --> (119:54-120:4) ".ReactDebugCurrentFrame;\n\t\t\t" -(204:4-204:8) " var" --> (120:4-120:8) "\tvar" -(204:8-204:16) " stack =" --> (120:8-120:16) " stack =" -(204:16-204:39) " ReactDebugCurrentFrame" --> (120:16-120:39) " ReactDebugCurrentFrame" -(204:39-204:57) ".getStackAddendum(" --> (120:39-120:57) ".getStackAddendum(" -(204:57-206:4) ");\n\n " --> (120:57-121:0) ");" -(206:4-206:8) " if " --> (121:0-121:8) "\n\t\t\t\tif " -(206:8-206:18) "(stack !==" --> (121:8-121:18) "(stack !==" -(206:18-206:22) " '')" --> (121:18-121:22) " \"\")" -(206:22-207:6) " {\n " --> (121:22-122:0) " {" -(207:6-207:16) " format +=" --> (122:0-122:15) "\n\t\t\t\t\tformat +=" -(207:16-208:6) " '%s';\n " --> (122:15-123:0) " \"%s\";" -(208:6-208:13) " args =" --> (123:0-123:12) "\n\t\t\t\t\targs =" -(208:13-208:18) " args" --> (123:12-123:17) " args" -(208:18-208:25) ".concat" --> (123:17-123:24) ".concat" -(208:25-208:26) "(" --> (123:24-123:25) "(" -(208:26-208:32) "[stack" --> (123:25-123:31) "[stack" -(208:32-208:33) "]" --> (123:31-123:32) "]" -(208:33-209:5) ");\n " --> (123:32-124:4) ");\n\t\t\t" -(209:5-211:4) "}\n\n " --> (124:4-125:4) "\t}\n\t\t\t" -(211:4-211:8) " var" --> (125:4-125:8) "\tvar" -(211:8-211:25) " argsWithFormat =" --> (125:8-125:25) " argsWithFormat =" -(211:25-211:30) " args" --> (125:25-125:30) " args" -(211:30-211:34) ".map" --> (125:30-125:34) ".map" -(211:34-211:44) "(function " --> (125:34-125:43) "(function" -(211:44-211:50) "(item)" --> (125:43-125:49) "(item)" -(211:50-212:6) " {\n " --> (125:49-126:0) " {" -(212:6-212:13) " return" --> (126:0-126:12) "\n\t\t\t\t\treturn" -(212:13-212:18) " '' +" --> (126:12-126:17) " \"\" +" -(212:18-213:5) " item;\n " --> (126:17-127:4) " item;\n\t\t\t" -(213:5-213:6) "}" --> (127:4-127:6) "\t}" -(213:6-215:4) "); // Careful: RN currently depends on this prefix\n\n " --> (127:6-128:0) ");" -(215:4-215:19) " argsWithFormat" --> (128:0-128:19) "\n\t\t\t\targsWithFormat" -(215:19-215:27) ".unshift" --> (128:19-128:27) ".unshift" -(215:27-215:41) "('Warning: ' +" --> (128:27-128:41) "(\"Warning: \" +" -(215:41-215:48) " format" --> (128:41-128:48) " format" -(215:48-219:4) "); // We intentionally don't use spread (or .apply) directly because it\n // breaks IE9: https://github.com/facebook/react/issues/13610\n // eslint-disable-next-line react-internal/no-production-logging\n\n " --> (128:48-129:0) ");" -(219:4-219:13) " Function" --> (129:0-129:13) "\n\t\t\t\tFunction" -(219:13-219:23) ".prototype" --> (129:13-129:23) ".prototype" -(219:23-219:29) ".apply" --> (129:23-129:29) ".apply" -(219:29-219:34) ".call" --> (129:29-129:34) ".call" -(219:34-219:42) "(console" --> (129:34-129:42) "(console" -(219:42-219:50) "[level]," --> (129:42-129:50) "[level]," -(219:50-219:59) " console," --> (129:50-129:59) " console," -(219:59-219:74) " argsWithFormat" --> (129:59-129:74) " argsWithFormat" -(219:74-220:3) ");\n " --> (129:74-130:3) ");\n\t\t" -(220:3-221:1) "}\n" --> (130:3-131:2) "\t}\n\t" -(221:1-223:0) "}\n" --> (131:2-132:2) "\t}\n\t" -(223:0-223:4) "\nvar" --> (132:2-132:6) "\tvar" -(223:4-223:46) " didWarnStateUpdateForUnmountedComponent =" --> (132:6-132:48) " didWarnStateUpdateForUnmountedComponent =" -(223:46-223:48) " {" --> (132:48-132:49) " " -(223:48-225:0) "};\n" --> (132:49-133:2) "{};\n\t" -(225:0-225:9) "\nfunction" --> (133:2-133:11) "\tfunction" -(225:9-225:18) " warnNoop" --> (133:11-133:20) " warnNoop" -(225:18-225:34) "(publicInstance," --> (133:20-133:36) "(publicInstance," -(225:34-225:46) " callerName)" --> (133:36-133:48) " callerName)" -(225:46-226:2) " {\n " --> (133:48-134:3) " {\n\t\t" -(226:2-227:4) " {\n " --> (134:3-135:4) "\t{\n\t\t\t" -(227:4-227:8) " var" --> (135:4-135:8) "\tvar" -(227:8-227:23) " _constructor =" --> (135:8-135:23) " _constructor =" -(227:23-227:38) " publicInstance" --> (135:23-135:38) " publicInstance" -(227:38-228:4) ".constructor;\n " --> (135:38-136:4) ".constructor;\n\t\t\t" -(228:4-228:8) " var" --> (136:4-136:8) "\tvar" -(228:8-228:24) " componentName =" --> (136:8-136:24) " componentName =" -(228:24-228:41) " _constructor && " --> (136:24-136:41) " _constructor && " -(228:41-228:54) "(_constructor" --> (136:41-136:54) "(_constructor" -(228:54-228:69) ".displayName ||" --> (136:54-136:69) ".displayName ||" -(228:69-228:82) " _constructor" --> (136:69-136:82) " _constructor" -(228:82-228:91) ".name) ||" --> (136:82-136:91) ".name) ||" -(228:91-229:4) " 'ReactClass';\n " --> (136:91-137:4) " \"ReactClass\";\n\t\t\t" -(229:4-229:8) " var" --> (137:4-137:8) "\tvar" -(229:8-229:21) " warningKey =" --> (137:8-137:21) " warningKey =" -(229:21-229:37) " componentName +" --> (137:21-137:37) " componentName +" -(229:37-229:43) " \".\" +" --> (137:37-137:43) " \".\" +" -(229:43-231:4) " callerName;\n\n " --> (137:43-138:0) " callerName;" -(231:4-231:8) " if " --> (138:0-138:8) "\n\t\t\t\tif " -(231:8-231:48) "(didWarnStateUpdateForUnmountedComponent" --> (138:8-138:48) "(didWarnStateUpdateForUnmountedComponent" -(231:48-231:61) "[warningKey])" --> (138:48-138:61) "[warningKey])" -(231:61-232:6) " {\n " --> (138:61-139:0) " {" -(232:6-233:5) " return;\n " --> (139:0-140:4) "\n\t\t\t\t\treturn;\n\t\t\t" -(233:5-235:4) "}\n\n " --> (140:4-141:0) "\t}" -(235:4-235:10) " error" --> (141:0-141:10) "\n\t\t\t\terror" -(235:10-235:69) "(\"Can't call %s on a component that is not yet mounted. \" +" --> (141:10-141:69) "(\"Can't call %s on a component that is not yet mounted. \" +" -(235:69-235:140) " 'This is a no-op, but it might indicate a bug in your application. ' +" --> (141:69-141:140) " \"This is a no-op, but it might indicate a bug in your application. \" +" -(235:140-235:212) " 'Instead, assign to `this.state` directly or define a `state = {};` ' +" --> (141:140-141:212) " \"Instead, assign to `this.state` directly or define a `state = {};` \" +" -(235:212-235:274) " 'class property with the desired state in the %s component.'," --> (141:212-141:274) " \"class property with the desired state in the %s component.\"," -(235:274-235:286) " callerName," --> (141:274-141:286) " callerName," -(235:286-235:300) " componentName" --> (141:286-141:300) " componentName" -(235:300-237:4) ");\n\n " --> (141:300-142:0) ");" -(237:4-237:44) " didWarnStateUpdateForUnmountedComponent" --> (142:0-142:44) "\n\t\t\t\tdidWarnStateUpdateForUnmountedComponent" -(237:44-237:58) "[warningKey] =" --> (142:44-142:58) "[warningKey] =" -(237:58-238:3) " true;\n " --> (142:58-143:3) " true;\n\t\t" -(238:3-239:1) "}\n" --> (143:3-144:2) "\t}\n\t" -(239:1-245:0) "}\n/**\n * This is the abstract API for an update queue.\n */\n\n" --> (144:2-145:2) "\t}\n\t" -(245:0-245:4) "\nvar" --> (145:2-145:6) "\tvar" -(245:4-245:27) " ReactNoopUpdateQueue =" --> (145:6-145:29) " ReactNoopUpdateQueue =" -(245:27-253:2) " {\n /**\n * Checks whether or not this composite component is mounted.\n * @param {ReactClass} publicInstance The instance we want to test.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n " --> (145:29-146:3) " {\n\t\t" -(253:2-253:13) " isMounted:" --> (146:3-146:14) "\tisMounted:" -(253:13-253:23) " function " --> (146:14-146:23) " function" -(253:23-253:39) "(publicInstance)" --> (146:23-146:39) "(publicInstance)" -(253:39-254:4) " {\n " --> (146:39-147:0) " {" -(254:4-254:11) " return" --> (147:0-147:11) "\n\t\t\t\treturn" -(254:11-255:3) " false;\n " --> (147:11-148:3) " false;\n\t\t" -(255:3-272:2) "},\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {?function} callback Called after component is updated.\n * @param {?string} callerName name of the calling function in the public API.\n * @internal\n */\n " --> (148:3-149:3) "\t},\n\t\t" -(272:2-272:22) " enqueueForceUpdate:" --> (149:3-149:23) "\tenqueueForceUpdate:" -(272:22-272:32) " function " --> (149:23-149:32) " function" -(272:32-272:48) "(publicInstance," --> (149:32-149:48) "(publicInstance," -(272:48-272:58) " callback," --> (149:48-149:58) " callback," -(272:58-272:70) " callerName)" --> (149:58-149:70) " callerName)" -(272:70-273:4) " {\n " --> (149:70-150:0) " {" -(273:4-273:13) " warnNoop" --> (150:0-150:13) "\n\t\t\t\twarnNoop" -(273:13-273:29) "(publicInstance," --> (150:13-150:29) "(publicInstance," -(273:29-273:43) " 'forceUpdate'" --> (150:29-150:43) " \"forceUpdate\"" -(273:43-274:3) ");\n " --> (150:43-151:3) ");\n\t\t" -(274:3-289:2) "},\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @param {?function} callback Called after component is updated.\n * @param {?string} callerName name of the calling function in the public API.\n * @internal\n */\n " --> (151:3-152:3) "\t},\n\t\t" -(289:2-289:23) " enqueueReplaceState:" --> (152:3-152:24) "\tenqueueReplaceState:" -(289:23-289:33) " function " --> (152:24-152:33) " function" -(289:33-289:49) "(publicInstance," --> (152:33-152:49) "(publicInstance," -(289:49-289:64) " completeState," --> (152:49-152:64) " completeState," -(289:64-289:74) " callback," --> (152:64-152:74) " callback," -(289:74-289:86) " callerName)" --> (152:74-152:86) " callerName)" -(289:86-290:4) " {\n " --> (152:86-153:0) " {" -(290:4-290:13) " warnNoop" --> (153:0-153:13) "\n\t\t\t\twarnNoop" -(290:13-290:29) "(publicInstance," --> (153:13-153:29) "(publicInstance," -(290:29-290:44) " 'replaceState'" --> (153:29-153:44) " \"replaceState\"" -(290:44-291:3) ");\n " --> (153:44-154:3) ");\n\t\t" -(291:3-305:2) "},\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @param {?function} callback Called after component is updated.\n * @param {?string} Name of the calling function in the public API.\n * @internal\n */\n " --> (154:3-155:3) "\t},\n\t\t" -(305:2-305:19) " enqueueSetState:" --> (155:3-155:20) "\tenqueueSetState:" -(305:19-305:29) " function " --> (155:20-155:29) " function" -(305:29-305:45) "(publicInstance," --> (155:29-155:45) "(publicInstance," -(305:45-305:59) " partialState," --> (155:45-155:59) " partialState," -(305:59-305:69) " callback," --> (155:59-155:69) " callback," -(305:69-305:81) " callerName)" --> (155:69-155:81) " callerName)" -(305:81-306:4) " {\n " --> (155:81-156:0) " {" -(306:4-306:13) " warnNoop" --> (156:0-156:13) "\n\t\t\t\twarnNoop" -(306:13-306:29) "(publicInstance," --> (156:13-156:29) "(publicInstance," -(306:29-306:40) " 'setState'" --> (156:29-156:40) " \"setState\"" -(306:40-307:3) ");\n " --> (156:40-157:3) ");\n\t\t" -(307:3-308:1) "}\n" --> (157:3-158:2) "\t}\n\t" -(308:1-310:0) "};\n" --> (158:2-159:2) "\t};\n\t" -(310:0-310:4) "\nvar" --> (159:2-159:6) "\tvar" -(310:4-310:18) " emptyObject =" --> (159:6-159:20) " emptyObject =" -(310:18-310:20) " {" --> (159:20-159:21) " " -(310:20-312:0) "};\n" --> (159:21-160:2) "{};\n\t" -(312:0-313:2) "\n{\n " --> (160:2-161:0) "\t{" -(313:2-313:9) " Object" --> (161:0-161:10) "\n\t\t\tObject" -(313:9-313:16) ".freeze" --> (161:10-161:17) ".freeze" -(313:16-313:28) "(emptyObject" --> (161:17-161:29) "(emptyObject" -(313:28-314:1) ");\n" --> (161:29-162:2) ");\n\t" -(314:1-320:0) "}\n/**\n * Base class helpers for the updating state of a component.\n */\n\n" --> (162:2-163:2) "\t}\n\t" -(320:0-320:9) "\nfunction" --> (163:2-163:11) "\tfunction" -(320:9-320:19) " Component" --> (163:11-163:21) " Component" -(320:19-320:26) "(props," --> (163:21-163:28) "(props," -(320:26-320:35) " context," --> (163:28-163:37) " context," -(320:35-320:44) " updater)" --> (163:37-163:46) " updater)" -(320:44-321:2) " {\n " --> (163:46-164:0) " {" -(321:2-321:7) " this" --> (164:0-164:8) "\n\t\t\tthis" -(321:7-321:15) ".props =" --> (164:8-164:16) ".props =" -(321:15-322:2) " props;\n " --> (164:16-165:0) " props;" -(322:2-322:7) " this" --> (165:0-165:8) "\n\t\t\tthis" -(322:7-322:17) ".context =" --> (165:8-165:18) ".context =" -(322:17-324:2) " context; // If a component has string refs, we will assign a different object later.\n\n " --> (165:18-166:0) " context;" -(324:2-324:7) " this" --> (166:0-166:8) "\n\t\t\tthis" -(324:7-324:14) ".refs =" --> (166:8-166:15) ".refs =" -(324:14-327:2) " emptyObject; // We initialize the default updater but the real one gets injected by the\n // renderer.\n\n " --> (166:15-167:0) " emptyObject;" -(327:2-327:7) " this" --> (167:0-167:8) "\n\t\t\tthis" -(327:7-327:17) ".updater =" --> (167:8-167:18) ".updater =" -(327:17-327:28) " updater ||" --> (167:18-167:29) " updater ||" -(327:28-328:1) " ReactNoopUpdateQueue;\n" --> (167:29-168:2) " ReactNoopUpdateQueue;\n\t" -(328:1-330:0) "}\n" --> (168:2-169:0) "\t}" -(330:0-330:10) "\nComponent" --> (169:0-169:12) "\n\t\tComponent" -(330:10-330:20) ".prototype" --> (169:12-169:22) ".prototype" -(330:20-330:39) ".isReactComponent =" --> (169:22-169:41) ".isReactComponent =" -(330:39-330:41) " {" --> (169:41-169:42) " " -(330:41-357:0) "};\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together. You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n * produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\n" --> (169:42-170:0) "{};" -(357:0-357:10) "\nComponent" --> (170:0-170:12) "\n\t\tComponent" -(357:10-357:20) ".prototype" --> (170:12-170:22) ".prototype" -(357:20-357:31) ".setState =" --> (170:22-170:33) ".setState =" -(357:31-357:41) " function " --> (170:33-170:42) " function" -(357:41-357:55) "(partialState," --> (170:42-170:56) "(partialState," -(357:55-357:65) " callback)" --> (170:56-170:66) " callback)" -(357:65-358:2) " {\n " --> (170:66-171:0) " {" -(358:2-358:15) " if (!(typeof" --> (171:0-171:16) "\n\t\t\tif (!(typeof" -(358:15-358:32) " partialState ===" --> (171:16-171:33) " partialState ===" -(358:32-358:51) " 'object' || typeof" --> (171:33-171:52) " \"object\" || typeof" -(358:51-358:68) " partialState ===" --> (171:52-171:69) " partialState ===" -(358:68-358:82) " 'function' ||" --> (171:69-171:83) " \"function\" ||" -(358:82-358:98) " partialState ==" --> (171:83-171:99) " partialState ==" -(358:98-358:105) " null))" --> (171:99-171:106) " null))" -(358:105-359:4) " {\n " --> (171:106-172:4) " {\n\t\t\t" -(359:4-360:6) " {\n " --> (172:4-173:0) "\t{" -(360:6-360:12) " throw" --> (173:0-173:11) "\n\t\t\t\t\tthrow" -(360:12-360:19) " Error(" --> (173:11-173:17) " Error" -(360:19-360:140) " \"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\" " --> (173:17-173:137) "(\"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\"" -(360:140-361:5) ");\n " --> (173:137-174:4) ");\n\t\t\t" -(361:5-362:3) "}\n " --> (174:4-175:3) "\t}\n\t\t" -(362:3-364:2) "}\n\n " --> (175:3-176:0) "\t}" -(364:2-364:7) " this" --> (176:0-176:8) "\n\t\t\tthis" -(364:7-364:15) ".updater" --> (176:8-176:16) ".updater" -(364:15-364:31) ".enqueueSetState" --> (176:16-176:32) ".enqueueSetState" -(364:31-364:37) "(this," --> (176:32-176:38) "(this," -(364:37-364:51) " partialState," --> (176:38-176:52) " partialState," -(364:51-364:61) " callback," --> (176:52-176:62) " callback," -(364:61-364:72) " 'setState'" --> (176:62-176:73) " \"setState\"" -(364:72-365:1) ");\n" --> (176:73-177:2) ");\n\t" -(365:1-382:0) "};\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\n\n" --> (177:2-178:0) "\t};" -(382:0-382:10) "\nComponent" --> (178:0-178:12) "\n\t\tComponent" -(382:10-382:20) ".prototype" --> (178:12-178:22) ".prototype" -(382:20-382:34) ".forceUpdate =" --> (178:22-178:36) ".forceUpdate =" -(382:34-382:44) " function " --> (178:36-178:45) " function" -(382:44-382:54) "(callback)" --> (178:45-178:55) "(callback)" -(382:54-383:2) " {\n " --> (178:55-179:0) " {" -(383:2-383:7) " this" --> (179:0-179:8) "\n\t\t\tthis" -(383:7-383:15) ".updater" --> (179:8-179:16) ".updater" -(383:15-383:34) ".enqueueForceUpdate" --> (179:16-179:35) ".enqueueForceUpdate" -(383:34-383:40) "(this," --> (179:35-179:41) "(this," -(383:40-383:50) " callback," --> (179:41-179:51) " callback," -(383:50-383:64) " 'forceUpdate'" --> (179:51-179:65) " \"forceUpdate\"" -(383:64-384:1) ");\n" --> (179:65-180:2) ");\n\t" -(384:1-392:0) "};\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\n\n" --> (180:2-181:2) "\t};\n\t" -(392:0-393:2) "\n{\n " --> (181:2-182:3) "\t{\n\t\t" -(393:2-393:6) " var" --> (182:3-182:7) "\tvar" -(393:6-393:23) " deprecatedAPIs =" --> (182:7-182:24) " deprecatedAPIs =" -(393:23-394:4) " {\n " --> (182:24-183:4) " {\n\t\t\t" -(394:4-394:15) " isMounted:" --> (183:4-183:15) "\tisMounted:" -(394:15-394:16) " " --> (183:15-183:16) " " -(394:16-394:29) "['isMounted'," --> (183:16-183:29) "[\"isMounted\"," -(394:29-394:103) " 'Instead, make sure to clean up subscriptions and pending requests in ' +" --> (183:29-183:103) " \"Instead, make sure to clean up subscriptions and pending requests in \" +" -(394:103-394:151) " 'componentWillUnmount to prevent memory leaks.'" --> (183:103-183:151) " \"componentWillUnmount to prevent memory leaks.\"" -(394:151-395:4) "],\n " --> (183:151-184:4) "],\n\t\t\t" -(395:4-395:18) " replaceState:" --> (184:4-184:18) "\treplaceState:" -(395:18-395:19) " " --> (184:18-184:19) " " -(395:19-395:35) "['replaceState'," --> (184:19-184:35) "[\"replaceState\"," -(395:35-395:88) " 'Refactor your code to use setState instead (see ' +" --> (184:35-184:88) " \"Refactor your code to use setState instead (see \" +" -(395:88-395:138) " 'https://github.com/facebook/react/issues/3236).'" --> (184:88-184:138) " \"https://github.com/facebook/react/issues/3236).\"" -(395:138-396:3) "]\n " --> (184:138-185:3) "]\n\t\t" -(396:3-398:2) "};\n\n " --> (185:3-186:3) "\t};\n\t\t" -(398:2-398:6) " var" --> (186:3-186:7) "\tvar" -(398:6-398:33) " defineDeprecationWarning =" --> (186:7-186:34) " defineDeprecationWarning =" -(398:33-398:43) " function " --> (186:34-186:43) " function" -(398:43-398:55) "(methodName," --> (186:43-186:55) "(methodName," -(398:55-398:61) " info)" --> (186:55-186:61) " info)" -(398:61-399:4) " {\n " --> (186:61-187:0) " {" -(399:4-399:11) " Object" --> (187:0-187:11) "\n\t\t\t\tObject" -(399:11-399:26) ".defineProperty" --> (187:11-187:26) ".defineProperty" -(399:26-399:36) "(Component" --> (187:26-187:36) "(Component" -(399:36-399:47) ".prototype," --> (187:36-187:47) ".prototype," -(399:47-399:59) " methodName," --> (187:47-187:59) " methodName," -(399:59-400:6) " {\n " --> (187:59-187:61) " {" -(400:6-400:11) " get:" --> (187:61-187:66) " get:" -(400:11-400:23) " function ()" --> (187:66-187:77) " function()" -(400:23-401:8) " {\n " --> (187:77-188:0) " {" -(401:8-401:13) " warn" --> (188:0-188:10) "\n\t\t\t\t\twarn" -(401:13-401:76) "('%s(...) is deprecated in plain JavaScript React classes. %s'," --> (188:10-188:73) "(\"%s(...) is deprecated in plain JavaScript React classes. %s\"," -(401:76-401:81) " info" --> (188:73-188:78) " info" -(401:81-401:85) "[0]," --> (188:78-188:82) "[0]," -(401:85-401:90) " info" --> (188:82-188:87) " info" -(401:90-401:93) "[1]" --> (188:87-188:90) "[1]" -(401:93-403:8) ");\n\n " --> (188:90-189:0) ");" -(403:8-403:15) " return" --> (189:0-189:12) "\n\t\t\t\t\treturn" -(403:15-404:7) " undefined;\n " --> (189:12-190:4) " undefined;\n\t\t\t" -(404:7-405:5) "}\n " --> (190:4-190:6) "\t}" -(405:5-405:6) "}" --> (190:6-190:8) " }" -(405:6-406:3) ");\n " --> (190:8-191:3) ");\n\t\t" -(406:3-408:2) "};\n\n " --> (191:3-192:0) "\t};" -(408:2-408:7) " for " --> (192:0-192:8) "\n\t\t\tfor " -(408:7-408:11) "(var" --> (192:8-192:12) "(var" -(408:11-408:21) " fnName in" --> (192:12-192:22) " fnName in" -(408:21-408:37) " deprecatedAPIs)" --> (192:22-192:38) " deprecatedAPIs)" -(408:37-409:4) " {\n " --> (192:38-193:0) " {" -(409:4-409:8) " if " --> (193:0-193:8) "\n\t\t\t\tif " -(409:8-409:23) "(deprecatedAPIs" --> (193:8-193:23) "(deprecatedAPIs" -(409:23-409:38) ".hasOwnProperty" --> (193:23-193:38) ".hasOwnProperty" -(409:38-409:45) "(fnName" --> (193:38-193:45) "(fnName" -(409:45-409:47) "))" --> (193:45-193:47) "))" -(409:47-410:6) " {\n " --> (193:47-194:0) " {" -(410:6-410:31) " defineDeprecationWarning" --> (194:0-194:30) "\n\t\t\t\t\tdefineDeprecationWarning" -(410:31-410:39) "(fnName," --> (194:30-194:38) "(fnName," -(410:39-410:54) " deprecatedAPIs" --> (194:38-194:53) " deprecatedAPIs" -(410:54-410:62) "[fnName]" --> (194:53-194:61) "[fnName]" -(410:62-411:5) ");\n " --> (194:61-195:4) ");\n\t\t\t" -(411:5-412:3) "}\n " --> (195:4-196:3) "\t}\n\t\t" -(412:3-413:1) "}\n" --> (196:3-197:2) "\t}\n\t" -(413:1-415:0) "}\n" --> (197:2-198:2) "\t}\n\t" -(415:0-415:9) "\nfunction" --> (198:2-198:11) "\tfunction" -(415:9-415:26) " ComponentDummy()" --> (198:11-198:28) " ComponentDummy()" -(415:26-415:28) " {" --> (198:28-198:29) " " -(415:28-417:0) "}\n" --> (198:29-199:0) "{}" -(417:0-417:15) "\nComponentDummy" --> (199:0-199:17) "\n\t\tComponentDummy" -(417:15-417:27) ".prototype =" --> (199:17-199:29) ".prototype =" -(417:27-417:37) " Component" --> (199:29-199:39) " Component" -(417:37-422:0) ".prototype;\n/**\n * Convenience component with default shallow equality check for sCU.\n */\n" --> (199:39-200:2) ".prototype;\n\t" -(422:0-422:9) "\nfunction" --> (200:2-200:11) "\tfunction" -(422:9-422:23) " PureComponent" --> (200:11-200:25) " PureComponent" -(422:23-422:30) "(props," --> (200:25-200:32) "(props," -(422:30-422:39) " context," --> (200:32-200:41) " context," -(422:39-422:48) " updater)" --> (200:41-200:50) " updater)" -(422:48-423:2) " {\n " --> (200:50-201:0) " {" -(423:2-423:7) " this" --> (201:0-201:8) "\n\t\t\tthis" -(423:7-423:15) ".props =" --> (201:8-201:16) ".props =" -(423:15-424:2) " props;\n " --> (201:16-202:0) " props;" -(424:2-424:7) " this" --> (202:0-202:8) "\n\t\t\tthis" -(424:7-424:17) ".context =" --> (202:8-202:18) ".context =" -(424:17-426:2) " context; // If a component has string refs, we will assign a different object later.\n\n " --> (202:18-203:0) " context;" -(426:2-426:7) " this" --> (203:0-203:8) "\n\t\t\tthis" -(426:7-426:14) ".refs =" --> (203:8-203:15) ".refs =" -(426:14-427:2) " emptyObject;\n " --> (203:15-204:0) " emptyObject;" -(427:2-427:7) " this" --> (204:0-204:8) "\n\t\t\tthis" -(427:7-427:17) ".updater =" --> (204:8-204:18) ".updater =" -(427:17-427:28) " updater ||" --> (204:18-204:29) " updater ||" -(427:28-428:1) " ReactNoopUpdateQueue;\n" --> (204:29-205:2) " ReactNoopUpdateQueue;\n\t" -(428:1-430:0) "}\n" --> (205:2-206:2) "\t}\n\t" -(430:0-430:4) "\nvar" --> (206:2-206:6) "\tvar" -(430:4-430:29) " pureComponentPrototype =" --> (206:6-206:31) " pureComponentPrototype =" -(430:29-430:43) " PureComponent" --> (206:31-206:45) " PureComponent" -(430:43-430:55) ".prototype =" --> (206:45-206:57) ".prototype =" -(430:55-430:59) " new" --> (206:57-206:61) " new" -(430:59-431:0) " ComponentDummy();" --> (206:61-207:0) " ComponentDummy();" -(431:0-431:23) "\npureComponentPrototype" --> (207:0-207:25) "\n\t\tpureComponentPrototype" -(431:23-431:37) ".constructor =" --> (207:25-207:39) ".constructor =" -(431:37-433:0) " PureComponent; // Avoid an extra prototype jump for these methods.\n" --> (207:39-208:0) " PureComponent;" -(433:0-433:8) "\n_assign" --> (208:0-208:10) "\n\t\t_assign" -(433:8-433:32) "(pureComponentPrototype," --> (208:10-208:34) "(pureComponentPrototype," -(433:32-433:42) " Component" --> (208:34-208:44) " Component" -(433:42-433:52) ".prototype" --> (208:44-208:54) ".prototype" -(433:52-435:0) ");\n" --> (208:54-209:0) ");" -(435:0-435:23) "\npureComponentPrototype" --> (209:0-209:25) "\n\t\tpureComponentPrototype" -(435:23-435:46) ".isPureReactComponent =" --> (209:25-209:48) ".isPureReactComponent =" -(435:46-438:0) " true;\n\n// an immutable object with a single mutable value" --> (209:48-210:2) " true;\n\t" -(438:0-438:9) "\nfunction" --> (210:2-210:11) "\tfunction" -(438:9-438:21) " createRef()" --> (210:11-210:23) " createRef()" -(438:21-439:2) " {\n " --> (210:23-211:3) " {\n\t\t" -(439:2-439:6) " var" --> (211:3-211:7) "\tvar" -(439:6-439:18) " refObject =" --> (211:7-211:19) " refObject =" -(439:18-440:4) " {\n " --> (211:19-211:21) " {" -(440:4-440:13) " current:" --> (211:21-211:30) " current:" -(440:13-441:3) " null\n " --> (211:30-211:35) " null" -(441:3-443:2) "};\n\n " --> (211:35-212:3) " };\n\t\t" -(443:2-444:4) " {\n " --> (212:3-213:0) "\t{" -(444:4-444:11) " Object" --> (213:0-213:11) "\n\t\t\t\tObject" -(444:11-444:16) ".seal" --> (213:11-213:16) ".seal" -(444:16-444:26) "(refObject" --> (213:16-213:26) "(refObject" -(444:26-445:3) ");\n " --> (213:26-214:3) ");\n\t\t" -(445:3-447:2) "}\n\n " --> (214:3-215:0) "\t}" -(447:2-447:9) " return" --> (215:0-215:10) "\n\t\t\treturn" -(447:9-448:1) " refObject;\n" --> (215:10-216:2) " refObject;\n\t" -(448:1-450:0) "}\n" --> (216:2-217:2) "\t}\n\t" -(450:0-450:9) "\nfunction" --> (217:2-217:11) "\tfunction" -(450:9-450:24) " getWrappedName" --> (217:11-217:26) " getWrappedName" -(450:24-450:35) "(outerType," --> (217:26-217:37) "(outerType," -(450:35-450:46) " innerType," --> (217:37-217:48) " innerType," -(450:46-450:59) " wrapperName)" --> (217:48-217:61) " wrapperName)" -(450:59-451:2) " {\n " --> (217:61-218:3) " {\n\t\t" -(451:2-451:6) " var" --> (218:3-218:7) "\tvar" -(451:6-451:21) " functionName =" --> (218:7-218:22) " functionName =" -(451:21-451:31) " innerType" --> (218:22-218:32) " innerType" -(451:31-451:46) ".displayName ||" --> (218:32-218:47) ".displayName ||" -(451:46-451:56) " innerType" --> (218:47-218:57) " innerType" -(451:56-451:64) ".name ||" --> (218:57-218:65) ".name ||" -(451:64-452:2) " '';\n " --> (218:65-219:0) " \"\";" -(452:2-452:9) " return" --> (219:0-219:10) "\n\t\t\treturn" -(452:9-452:19) " outerType" --> (219:10-219:20) " outerType" -(452:19-452:35) ".displayName || " --> (219:20-219:36) ".displayName || " -(452:35-452:52) "(functionName !==" --> (219:36-219:53) "(functionName !==" -(452:52-452:57) " '' ?" --> (219:53-219:58) " \"\" ?" -(452:57-452:71) " wrapperName +" --> (219:58-219:72) " wrapperName +" -(452:71-452:77) " \"(\" +" --> (219:72-219:78) " \"(\" +" -(452:77-452:92) " functionName +" --> (219:78-219:93) " functionName +" -(452:92-452:98) " \")\" :" --> (219:93-219:99) " \")\" :" -(452:98-453:1) " wrapperName);\n" --> (219:99-220:2) " wrapperName);\n\t" -(453:1-455:0) "}\n" --> (220:2-221:2) "\t}\n\t" -(455:0-455:9) "\nfunction" --> (221:2-221:11) "\tfunction" -(455:9-455:24) " getContextName" --> (221:11-221:26) " getContextName" -(455:24-455:30) "(type)" --> (221:26-221:32) "(type)" -(455:30-456:2) " {\n " --> (221:32-222:0) " {" -(456:2-456:9) " return" --> (222:0-222:10) "\n\t\t\treturn" -(456:9-456:14) " type" --> (222:10-222:15) " type" -(456:14-456:29) ".displayName ||" --> (222:15-222:30) ".displayName ||" -(456:29-457:1) " 'Context';\n" --> (222:30-223:2) " \"Context\";\n\t" -(457:1-459:0) "}\n" --> (223:2-224:2) "\t}\n\t" -(459:0-459:9) "\nfunction" --> (224:2-224:11) "\tfunction" -(459:9-459:26) " getComponentName" --> (224:11-224:28) " getComponentName" -(459:26-459:32) "(type)" --> (224:28-224:34) "(type)" -(459:32-460:2) " {\n " --> (224:34-225:0) " {" -(460:2-460:6) " if " --> (225:0-225:7) "\n\t\t\tif " -(460:6-460:14) "(type ==" --> (225:7-225:15) "(type ==" -(460:14-460:20) " null)" --> (225:15-225:21) " null)" -(460:20-462:4) " {\n // Host root, text node or just invalid type.\n " --> (225:21-226:0) " {" -(462:4-462:11) " return" --> (226:0-226:11) "\n\t\t\t\treturn" -(462:11-463:3) " null;\n " --> (226:11-227:3) " null;\n\t\t" -(463:3-465:2) "}\n\n " --> (227:3-228:3) "\t}\n\t\t" -(465:2-466:4) " {\n " --> (228:3-229:0) "\t{" -(466:4-466:15) " if (typeof" --> (229:0-229:15) "\n\t\t\t\tif (typeof" -(466:15-466:20) " type" --> (229:15-229:20) " type" -(466:20-466:28) ".tag ===" --> (229:20-229:28) ".tag ===" -(466:28-466:38) " 'number')" --> (229:28-229:38) " \"number\")" -(466:38-467:6) " {\n " --> (229:38-230:0) " {" -(467:6-467:12) " error" --> (230:0-230:11) "\n\t\t\t\t\terror" -(467:12-467:70) "('Received an unexpected object in getComponentName(). ' +" --> (230:11-230:69) "(\"Received an unexpected object in getComponentName(). \" +" -(467:70-467:125) " 'This is likely a bug in React. Please file an issue.'" --> (230:69-230:124) " \"This is likely a bug in React. Please file an issue.\"" -(467:125-468:5) ");\n " --> (230:124-231:4) ");\n\t\t\t" -(468:5-469:3) "}\n " --> (231:4-232:3) "\t}\n\t\t" -(469:3-471:2) "}\n\n " --> (232:3-233:0) "\t}" -(471:2-471:13) " if (typeof" --> (233:0-233:14) "\n\t\t\tif (typeof" -(471:13-471:22) " type ===" --> (233:14-233:23) " type ===" -(471:22-471:34) " 'function')" --> (233:23-233:35) " \"function\")" -(471:34-472:4) " {\n " --> (233:35-234:0) " {" -(472:4-472:11) " return" --> (234:0-234:11) "\n\t\t\t\treturn" -(472:11-472:16) " type" --> (234:11-234:16) " type" -(472:16-472:31) ".displayName ||" --> (234:16-234:31) ".displayName ||" -(472:31-472:36) " type" --> (234:31-234:36) " type" -(472:36-472:44) ".name ||" --> (234:36-234:44) ".name ||" -(472:44-473:3) " null;\n " --> (234:44-235:3) " null;\n\t\t" -(473:3-475:2) "}\n\n " --> (235:3-236:0) "\t}" -(475:2-475:13) " if (typeof" --> (236:0-236:14) "\n\t\t\tif (typeof" -(475:13-475:22) " type ===" --> (236:14-236:23) " type ===" -(475:22-475:32) " 'string')" --> (236:23-236:33) " \"string\")" -(475:32-476:4) " {\n " --> (236:33-237:0) " {" -(476:4-476:11) " return" --> (237:0-237:11) "\n\t\t\t\treturn" -(476:11-477:3) " type;\n " --> (237:11-238:3) " type;\n\t\t" -(477:3-479:2) "}\n\n " --> (238:3-239:0) "\t}" -(479:2-479:10) " switch " --> (239:0-239:11) "\n\t\t\tswitch " -(479:10-479:2) " switch " --> (239:11-239:17) "(type)" -(479:2-480:4) " switch (type) {\n " --> (239:17-240:0) " {" -(480:4-480:9) " case" --> (240:0-240:9) "\n\t\t\t\tcase" -(480:9-480:17) " exports" --> (240:9-240:17) " exports" -(480:17-481:6) ".Fragment:\n " --> (240:17-240:26) ".Fragment" -(481:6-481:13) " return" --> (240:26-240:34) ": return" -(481:13-483:4) " 'Fragment';\n\n " --> (240:34-241:0) " \"Fragment\";" -(483:4-483:9) " case" --> (241:0-241:9) "\n\t\t\t\tcase" -(483:9-484:6) " REACT_PORTAL_TYPE:\n " --> (241:9-241:27) " REACT_PORTAL_TYPE" -(484:6-484:13) " return" --> (241:27-241:35) ": return" -(484:13-486:4) " 'Portal';\n\n " --> (241:35-242:0) " \"Portal\";" -(486:4-486:9) " case" --> (242:0-242:9) "\n\t\t\t\tcase" -(486:9-486:17) " exports" --> (242:9-242:17) " exports" -(486:17-487:6) ".Profiler:\n " --> (242:17-242:26) ".Profiler" -(487:6-487:13) " return" --> (242:26-242:34) ": return" -(487:13-489:4) " 'Profiler';\n\n " --> (242:34-243:0) " \"Profiler\";" -(489:4-489:9) " case" --> (243:0-243:9) "\n\t\t\t\tcase" -(489:9-489:17) " exports" --> (243:9-243:17) " exports" -(489:17-490:6) ".StrictMode:\n " --> (243:17-243:28) ".StrictMode" -(490:6-490:13) " return" --> (243:28-243:36) ": return" -(490:13-492:4) " 'StrictMode';\n\n " --> (243:36-244:0) " \"StrictMode\";" -(492:4-492:9) " case" --> (244:0-244:9) "\n\t\t\t\tcase" -(492:9-492:17) " exports" --> (244:9-244:17) " exports" -(492:17-493:6) ".Suspense:\n " --> (244:17-244:26) ".Suspense" -(493:6-493:13) " return" --> (244:26-244:34) ": return" -(493:13-495:4) " 'Suspense';\n\n " --> (244:34-245:0) " \"Suspense\";" -(495:4-495:9) " case" --> (245:0-245:9) "\n\t\t\t\tcase" -(495:9-496:6) " REACT_SUSPENSE_LIST_TYPE:\n " --> (245:9-245:34) " REACT_SUSPENSE_LIST_TYPE" -(496:6-496:13) " return" --> (245:34-245:42) ": return" -(496:13-497:3) " 'SuspenseList';\n " --> (245:42-246:3) " \"SuspenseList\";\n\t\t" -(497:3-499:2) "}\n\n " --> (246:3-247:0) "\t}" -(499:2-499:13) " if (typeof" --> (247:0-247:14) "\n\t\t\tif (typeof" -(499:13-499:22) " type ===" --> (247:14-247:23) " type ===" -(499:22-499:32) " 'object')" --> (247:23-247:33) " \"object\")" -(499:32-500:4) " {\n " --> (247:33-248:0) " {" -(500:4-500:12) " switch " --> (248:0-248:12) "\n\t\t\t\tswitch " -(500:12-500:17) "(type" --> (248:12-248:17) "(type" -(500:17-500:4) " switch (type" --> (248:17-248:27) ".$$typeof)" -(500:4-501:6) " switch (type.$$typeof) {\n " --> (248:27-249:0) " {" -(501:6-501:11) " case" --> (249:0-249:10) "\n\t\t\t\t\tcase" -(501:11-502:8) " REACT_CONTEXT_TYPE:\n " --> (249:10-250:6) " REACT_CONTEXT_TYPE:\n\t\t\t\t\t" -(502:8-502:12) " var" --> (250:6-250:10) "\tvar" -(502:12-502:22) " context =" --> (250:10-250:20) " context =" -(502:22-503:8) " type;\n " --> (250:20-251:0) " type;" -(503:8-503:15) " return" --> (251:0-251:13) "\n\t\t\t\t\t\treturn" -(503:15-503:30) " getContextName" --> (251:13-251:28) " getContextName" -(503:30-503:38) "(context" --> (251:28-251:36) "(context" -(503:38-503:41) ") +" --> (251:36-251:39) ") +" -(503:41-505:6) " '.Consumer';\n\n " --> (251:39-252:0) " \".Consumer\";" -(505:6-505:11) " case" --> (252:0-252:10) "\n\t\t\t\t\tcase" -(505:11-506:8) " REACT_PROVIDER_TYPE:\n " --> (252:10-253:6) " REACT_PROVIDER_TYPE:\n\t\t\t\t\t" -(506:8-506:12) " var" --> (253:6-253:10) "\tvar" -(506:12-506:23) " provider =" --> (253:10-253:21) " provider =" -(506:23-507:8) " type;\n " --> (253:21-254:0) " type;" -(507:8-507:15) " return" --> (254:0-254:13) "\n\t\t\t\t\t\treturn" -(507:15-507:30) " getContextName" --> (254:13-254:28) " getContextName" -(507:30-507:39) "(provider" --> (254:28-254:37) "(provider" -(507:39-507:48) "._context" --> (254:37-254:46) "._context" -(507:48-507:51) ") +" --> (254:46-254:49) ") +" -(507:51-509:6) " '.Provider';\n\n " --> (254:49-255:0) " \".Provider\";" -(509:6-509:11) " case" --> (255:0-255:10) "\n\t\t\t\t\tcase" -(509:11-510:8) " REACT_FORWARD_REF_TYPE:\n " --> (255:10-255:33) " REACT_FORWARD_REF_TYPE" -(510:8-510:15) " return" --> (255:33-255:41) ": return" -(510:15-510:30) " getWrappedName" --> (255:41-255:56) " getWrappedName" -(510:30-510:36) "(type," --> (255:56-255:62) "(type," -(510:36-510:41) " type" --> (255:62-255:67) " type" -(510:41-510:49) ".render," --> (255:67-255:75) ".render," -(510:49-510:62) " 'ForwardRef'" --> (255:75-255:88) " \"ForwardRef\"" -(510:62-512:6) ");\n\n " --> (255:88-256:0) ");" -(512:6-512:11) " case" --> (256:0-256:10) "\n\t\t\t\t\tcase" -(512:11-513:8) " REACT_MEMO_TYPE:\n " --> (256:10-256:26) " REACT_MEMO_TYPE" -(513:8-513:15) " return" --> (256:26-256:34) ": return" -(513:15-513:32) " getComponentName" --> (256:34-256:51) " getComponentName" -(513:32-513:37) "(type" --> (256:51-256:56) "(type" -(513:37-513:42) ".type" --> (256:56-256:61) ".type" -(513:42-515:6) ");\n\n " --> (256:61-257:0) ");" -(515:6-515:11) " case" --> (257:0-257:10) "\n\t\t\t\t\tcase" -(515:11-516:8) " REACT_BLOCK_TYPE:\n " --> (257:10-257:27) " REACT_BLOCK_TYPE" -(516:8-516:15) " return" --> (257:27-257:35) ": return" -(516:15-516:32) " getComponentName" --> (257:35-257:52) " getComponentName" -(516:32-516:37) "(type" --> (257:52-257:57) "(type" -(516:37-516:45) "._render" --> (257:57-257:65) "._render" -(516:45-518:6) ");\n\n " --> (257:65-258:0) ");" -(518:6-518:11) " case" --> (258:0-258:10) "\n\t\t\t\t\tcase" -(518:11-519:8) " REACT_LAZY_TYPE:\n " --> (258:10-258:27) " REACT_LAZY_TYPE:" -(519:8-520:10) " {\n " --> (258:27-259:6) " {\n\t\t\t\t\t" -(520:10-520:14) " var" --> (259:6-259:10) "\tvar" -(520:14-520:30) " lazyComponent =" --> (259:10-259:26) " lazyComponent =" -(520:30-521:10) " type;\n " --> (259:26-260:6) " type;\n\t\t\t\t\t" -(521:10-521:14) " var" --> (260:6-260:10) "\tvar" -(521:14-521:24) " payload =" --> (260:10-260:20) " payload =" -(521:24-521:38) " lazyComponent" --> (260:20-260:34) " lazyComponent" -(521:38-522:10) "._payload;\n " --> (260:34-261:6) "._payload;\n\t\t\t\t\t" -(522:10-522:14) " var" --> (261:6-261:10) "\tvar" -(522:14-522:21) " init =" --> (261:10-261:17) " init =" -(522:21-522:35) " lazyComponent" --> (261:17-261:31) " lazyComponent" -(522:35-524:10) "._init;\n\n " --> (261:31-262:0) "._init;" -(524:10-524:14) " try" --> (262:0-262:10) "\n\t\t\t\t\t\ttry" -(524:14-525:12) " {\n " --> (262:10-263:0) " {" -(525:12-525:19) " return" --> (263:0-263:14) "\n\t\t\t\t\t\t\treturn" -(525:19-525:36) " getComponentName" --> (263:14-263:31) " getComponentName" -(525:36-525:41) "(init" --> (263:31-263:36) "(init" -(525:41-525:49) "(payload" --> (263:36-263:44) "(payload" -(525:49-525:50) ")" --> (263:44-263:45) ")" -(525:50-526:11) ");\n " --> (263:45-264:6) ");\n\t\t\t\t\t" -(526:11-526:19) "} catch " --> (264:6-264:15) "\t} catch " -(526:19-526:22) "(x)" --> (264:15-264:18) "(x)" -(526:22-527:12) " {\n " --> (264:18-265:0) " {" -(527:12-527:19) " return" --> (265:0-265:14) "\n\t\t\t\t\t\t\treturn" -(527:19-528:11) " null;\n " --> (265:14-266:6) " null;\n\t\t\t\t\t" -(528:11-529:9) "}\n " --> (266:6-267:5) "\t}\n\t\t\t\t" -(529:9-530:5) "}\n " --> (267:5-268:4) "\t}\n\t\t\t" -(530:5-531:3) "}\n " --> (268:4-269:3) "\t}\n\t\t" -(531:3-533:2) "}\n\n " --> (269:3-270:0) "\t}" -(533:2-533:9) " return" --> (270:0-270:10) "\n\t\t\treturn" -(533:9-534:1) " null;\n" --> (270:10-271:2) " null;\n\t" -(534:1-536:0) "}\n" --> (271:2-272:2) "\t}\n\t" -(536:0-536:4) "\nvar" --> (272:2-272:6) "\tvar" -(536:4-536:21) " hasOwnProperty =" --> (272:6-272:23) " hasOwnProperty =" -(536:21-536:28) " Object" --> (272:23-272:30) " Object" -(536:28-536:38) ".prototype" --> (272:30-272:40) ".prototype" -(536:38-537:0) ".hasOwnProperty;" --> (272:40-273:2) ".hasOwnProperty;\n\t" -(537:0-537:4) "\nvar" --> (273:2-273:6) "\tvar" -(537:4-537:21) " RESERVED_PROPS =" --> (273:6-273:23) " RESERVED_PROPS =" -(537:21-538:2) " {\n " --> (273:23-274:3) " {\n\t\t" -(538:2-538:7) " key:" --> (274:3-274:8) "\tkey:" -(538:7-539:2) " true,\n " --> (274:8-275:3) " true,\n\t\t" -(539:2-539:7) " ref:" --> (275:3-275:8) "\tref:" -(539:7-540:2) " true,\n " --> (275:8-276:3) " true,\n\t\t" -(540:2-540:10) " __self:" --> (276:3-276:11) "\t__self:" -(540:10-541:2) " true,\n " --> (276:11-277:3) " true,\n\t\t" -(541:2-541:12) " __source:" --> (277:3-277:13) "\t__source:" -(541:12-542:1) " true\n" --> (277:13-278:2) " true\n\t" -(542:1-543:0) "};" --> (278:2-279:2) "\t};\n\t" -(543:0-543:4) "\nvar" --> (279:2-279:6) "\tvar" -(543:4-543:32) " specialPropKeyWarningShown," --> (279:6-279:34) " specialPropKeyWarningShown," -(543:32-543:60) " specialPropRefWarningShown," --> (279:34-279:62) " specialPropRefWarningShown," -(543:60-545:0) " didWarnAboutStringRefs;\n" --> (279:62-280:2) " didWarnAboutStringRefs;\n\t" -(545:0-546:2) "\n{\n " --> (280:2-281:0) "\t{" -(546:2-546:27) " didWarnAboutStringRefs =" --> (281:0-281:28) "\n\t\t\tdidWarnAboutStringRefs =" -(546:27-546:29) " {" --> (281:28-281:29) " " -(546:29-547:1) "};\n" --> (281:29-282:2) "{};\n\t" -(547:1-549:0) "}\n" --> (282:2-283:2) "\t}\n\t" -(549:0-549:9) "\nfunction" --> (283:2-283:11) "\tfunction" -(549:9-549:21) " hasValidRef" --> (283:11-283:23) " hasValidRef" -(549:21-549:29) "(config)" --> (283:23-283:31) "(config)" -(549:29-550:2) " {\n " --> (283:31-284:3) " {\n\t\t" -(550:2-551:4) " {\n " --> (284:3-285:0) "\t{" -(551:4-551:8) " if " --> (285:0-285:8) "\n\t\t\t\tif " -(551:8-551:23) "(hasOwnProperty" --> (285:8-285:23) "(hasOwnProperty" -(551:23-551:28) ".call" --> (285:23-285:28) ".call" -(551:28-551:36) "(config," --> (285:28-285:36) "(config," -(551:36-551:42) " 'ref'" --> (285:36-285:42) " \"ref\"" -(551:42-551:44) "))" --> (285:42-285:44) "))" -(551:44-552:6) " {\n " --> (285:44-286:5) " {\n\t\t\t\t" -(552:6-552:10) " var" --> (286:5-286:9) "\tvar" -(552:10-552:19) " getter =" --> (286:9-286:18) " getter =" -(552:19-552:26) " Object" --> (286:18-286:25) " Object" -(552:26-552:51) ".getOwnPropertyDescriptor" --> (286:25-286:50) ".getOwnPropertyDescriptor" -(552:51-552:59) "(config," --> (286:50-286:58) "(config," -(552:59-552:65) " 'ref'" --> (286:58-286:64) " \"ref\"" -(552:65-552:66) ")" --> (286:64-286:65) ")" -(552:66-554:6) ".get;\n\n " --> (286:65-287:0) ".get;" -(554:6-554:10) " if " --> (287:0-287:9) "\n\t\t\t\t\tif " -(554:10-554:20) "(getter &&" --> (287:9-287:19) "(getter &&" -(554:20-554:27) " getter" --> (287:19-287:26) " getter" -(554:27-554:43) ".isReactWarning)" --> (287:26-287:42) ".isReactWarning)" -(554:43-555:8) " {\n " --> (287:42-288:0) " {" -(555:8-555:15) " return" --> (288:0-288:13) "\n\t\t\t\t\t\treturn" -(555:15-556:7) " false;\n " --> (288:13-289:5) " false;\n\t\t\t\t" -(556:7-557:5) "}\n " --> (289:5-290:4) "\t}\n\t\t\t" -(557:5-558:3) "}\n " --> (290:4-291:3) "\t}\n\t\t" -(558:3-560:2) "}\n\n " --> (291:3-292:0) "\t}" -(560:2-560:9) " return" --> (292:0-292:10) "\n\t\t\treturn" -(560:9-560:16) " config" --> (292:10-292:17) " config" -(560:16-560:24) ".ref !==" --> (292:17-292:25) ".ref !==" -(560:24-561:1) " undefined;\n" --> (292:25-293:2) " undefined;\n\t" -(561:1-563:0) "}\n" --> (293:2-294:2) "\t}\n\t" -(563:0-563:9) "\nfunction" --> (294:2-294:11) "\tfunction" -(563:9-563:21) " hasValidKey" --> (294:11-294:23) " hasValidKey" -(563:21-563:29) "(config)" --> (294:23-294:31) "(config)" -(563:29-564:2) " {\n " --> (294:31-295:3) " {\n\t\t" -(564:2-565:4) " {\n " --> (295:3-296:0) "\t{" -(565:4-565:8) " if " --> (296:0-296:8) "\n\t\t\t\tif " -(565:8-565:23) "(hasOwnProperty" --> (296:8-296:23) "(hasOwnProperty" -(565:23-565:28) ".call" --> (296:23-296:28) ".call" -(565:28-565:36) "(config," --> (296:28-296:36) "(config," -(565:36-565:42) " 'key'" --> (296:36-296:42) " \"key\"" -(565:42-565:44) "))" --> (296:42-296:44) "))" -(565:44-566:6) " {\n " --> (296:44-297:5) " {\n\t\t\t\t" -(566:6-566:10) " var" --> (297:5-297:9) "\tvar" -(566:10-566:19) " getter =" --> (297:9-297:18) " getter =" -(566:19-566:26) " Object" --> (297:18-297:25) " Object" -(566:26-566:51) ".getOwnPropertyDescriptor" --> (297:25-297:50) ".getOwnPropertyDescriptor" -(566:51-566:59) "(config," --> (297:50-297:58) "(config," -(566:59-566:65) " 'key'" --> (297:58-297:64) " \"key\"" -(566:65-566:66) ")" --> (297:64-297:65) ")" -(566:66-568:6) ".get;\n\n " --> (297:65-298:0) ".get;" -(568:6-568:10) " if " --> (298:0-298:9) "\n\t\t\t\t\tif " -(568:10-568:20) "(getter &&" --> (298:9-298:19) "(getter &&" -(568:20-568:27) " getter" --> (298:19-298:26) " getter" -(568:27-568:43) ".isReactWarning)" --> (298:26-298:42) ".isReactWarning)" -(568:43-569:8) " {\n " --> (298:42-299:0) " {" -(569:8-569:15) " return" --> (299:0-299:13) "\n\t\t\t\t\t\treturn" -(569:15-570:7) " false;\n " --> (299:13-300:5) " false;\n\t\t\t\t" -(570:7-571:5) "}\n " --> (300:5-301:4) "\t}\n\t\t\t" -(571:5-572:3) "}\n " --> (301:4-302:3) "\t}\n\t\t" -(572:3-574:2) "}\n\n " --> (302:3-303:0) "\t}" -(574:2-574:9) " return" --> (303:0-303:10) "\n\t\t\treturn" -(574:9-574:16) " config" --> (303:10-303:17) " config" -(574:16-574:24) ".key !==" --> (303:17-303:25) ".key !==" -(574:24-575:1) " undefined;\n" --> (303:25-304:2) " undefined;\n\t" -(575:1-577:0) "}\n" --> (304:2-305:2) "\t}\n\t" -(577:0-577:9) "\nfunction" --> (305:2-305:11) "\tfunction" -(577:9-577:36) " defineKeyPropWarningGetter" --> (305:11-305:38) " defineKeyPropWarningGetter" -(577:36-577:43) "(props," --> (305:38-305:45) "(props," -(577:43-577:56) " displayName)" --> (305:45-305:58) " displayName)" -(577:56-578:2) " {\n " --> (305:58-306:3) " {\n\t\t" -(578:2-578:6) " var" --> (306:3-306:7) "\tvar" -(578:6-578:30) " warnAboutAccessingKey =" --> (306:7-306:31) " warnAboutAccessingKey =" -(578:30-578:42) " function ()" --> (306:31-306:42) " function()" -(578:42-579:4) " {\n " --> (306:42-307:4) " {\n\t\t\t" -(579:4-580:6) " {\n " --> (307:4-308:0) "\t{" -(580:6-580:11) " if (" --> (308:0-308:10) "\n\t\t\t\t\tif (" -(580:11-580:39) "!specialPropKeyWarningShown)" --> (308:10-308:38) "!specialPropKeyWarningShown)" -(580:39-581:8) " {\n " --> (308:38-309:0) " {" -(581:8-581:37) " specialPropKeyWarningShown =" --> (309:0-309:35) "\n\t\t\t\t\t\tspecialPropKeyWarningShown =" -(581:37-583:8) " true;\n\n " --> (309:35-310:0) " true;" -(583:8-583:14) " error" --> (310:0-310:12) "\n\t\t\t\t\t\terror" -(583:14-583:76) "('%s: `key` is not a prop. Trying to access it will result ' +" --> (310:12-310:74) "(\"%s: `key` is not a prop. Trying to access it will result \" +" -(583:76-583:143) " 'in `undefined` being returned. If you need to access the same ' +" --> (310:74-310:141) " \"in `undefined` being returned. If you need to access the same \" +" -(583:143-583:216) " 'value within the child component, you should pass it as a different ' +" --> (310:141-310:214) " \"value within the child component, you should pass it as a different \" +" -(583:216-583:266) " 'prop. (https://reactjs.org/link/special-props)'," --> (310:214-310:264) " \"prop. (https://reactjs.org/link/special-props)\"," -(583:266-583:278) " displayName" --> (310:264-310:276) " displayName" -(583:278-584:7) ");\n " --> (310:276-311:5) ");\n\t\t\t\t" -(584:7-585:5) "}\n " --> (311:5-312:4) "\t}\n\t\t\t" -(585:5-586:3) "}\n " --> (312:4-313:3) "\t}\n\t\t" -(586:3-588:2) "};\n\n " --> (313:3-314:0) "\t};" -(588:2-588:24) " warnAboutAccessingKey" --> (314:0-314:25) "\n\t\t\twarnAboutAccessingKey" -(588:24-588:41) ".isReactWarning =" --> (314:25-314:42) ".isReactWarning =" -(588:41-589:2) " true;\n " --> (314:42-315:0) " true;" -(589:2-589:9) " Object" --> (315:0-315:10) "\n\t\t\tObject" -(589:9-589:24) ".defineProperty" --> (315:10-315:25) ".defineProperty" -(589:24-589:31) "(props," --> (315:25-315:32) "(props," -(589:31-589:38) " 'key'," --> (315:32-315:39) " \"key\"," -(589:38-590:4) " {\n " --> (315:39-316:4) " {\n\t\t\t" -(590:4-590:9) " get:" --> (316:4-316:9) "\tget:" -(590:9-591:4) " warnAboutAccessingKey,\n " --> (316:9-317:4) " warnAboutAccessingKey,\n\t\t\t" -(591:4-591:18) " configurable:" --> (317:4-317:18) "\tconfigurable:" -(591:18-592:3) " true\n " --> (317:18-318:3) " true\n\t\t" -(592:3-592:4) "}" --> (318:3-318:5) "\t}" -(592:4-593:1) ");\n" --> (318:5-319:2) ");\n\t" -(593:1-595:0) "}\n" --> (319:2-320:2) "\t}\n\t" -(595:0-595:9) "\nfunction" --> (320:2-320:11) "\tfunction" -(595:9-595:36) " defineRefPropWarningGetter" --> (320:11-320:38) " defineRefPropWarningGetter" -(595:36-595:43) "(props," --> (320:38-320:45) "(props," -(595:43-595:56) " displayName)" --> (320:45-320:58) " displayName)" -(595:56-596:2) " {\n " --> (320:58-321:3) " {\n\t\t" -(596:2-596:6) " var" --> (321:3-321:7) "\tvar" -(596:6-596:30) " warnAboutAccessingRef =" --> (321:7-321:31) " warnAboutAccessingRef =" -(596:30-596:42) " function ()" --> (321:31-321:42) " function()" -(596:42-597:4) " {\n " --> (321:42-322:4) " {\n\t\t\t" -(597:4-598:6) " {\n " --> (322:4-323:0) "\t{" -(598:6-598:11) " if (" --> (323:0-323:10) "\n\t\t\t\t\tif (" -(598:11-598:39) "!specialPropRefWarningShown)" --> (323:10-323:38) "!specialPropRefWarningShown)" -(598:39-599:8) " {\n " --> (323:38-324:0) " {" -(599:8-599:37) " specialPropRefWarningShown =" --> (324:0-324:35) "\n\t\t\t\t\t\tspecialPropRefWarningShown =" -(599:37-601:8) " true;\n\n " --> (324:35-325:0) " true;" -(601:8-601:14) " error" --> (325:0-325:12) "\n\t\t\t\t\t\terror" -(601:14-601:76) "('%s: `ref` is not a prop. Trying to access it will result ' +" --> (325:12-325:74) "(\"%s: `ref` is not a prop. Trying to access it will result \" +" -(601:76-601:143) " 'in `undefined` being returned. If you need to access the same ' +" --> (325:74-325:141) " \"in `undefined` being returned. If you need to access the same \" +" -(601:143-601:216) " 'value within the child component, you should pass it as a different ' +" --> (325:141-325:214) " \"value within the child component, you should pass it as a different \" +" -(601:216-601:266) " 'prop. (https://reactjs.org/link/special-props)'," --> (325:214-325:264) " \"prop. (https://reactjs.org/link/special-props)\"," -(601:266-601:278) " displayName" --> (325:264-325:276) " displayName" -(601:278-602:7) ");\n " --> (325:276-326:5) ");\n\t\t\t\t" -(602:7-603:5) "}\n " --> (326:5-327:4) "\t}\n\t\t\t" -(603:5-604:3) "}\n " --> (327:4-328:3) "\t}\n\t\t" -(604:3-606:2) "};\n\n " --> (328:3-329:0) "\t};" -(606:2-606:24) " warnAboutAccessingRef" --> (329:0-329:25) "\n\t\t\twarnAboutAccessingRef" -(606:24-606:41) ".isReactWarning =" --> (329:25-329:42) ".isReactWarning =" -(606:41-607:2) " true;\n " --> (329:42-330:0) " true;" -(607:2-607:9) " Object" --> (330:0-330:10) "\n\t\t\tObject" -(607:9-607:24) ".defineProperty" --> (330:10-330:25) ".defineProperty" -(607:24-607:31) "(props," --> (330:25-330:32) "(props," -(607:31-607:38) " 'ref'," --> (330:32-330:39) " \"ref\"," -(607:38-608:4) " {\n " --> (330:39-331:4) " {\n\t\t\t" -(608:4-608:9) " get:" --> (331:4-331:9) "\tget:" -(608:9-609:4) " warnAboutAccessingRef,\n " --> (331:9-332:4) " warnAboutAccessingRef,\n\t\t\t" -(609:4-609:18) " configurable:" --> (332:4-332:18) "\tconfigurable:" -(609:18-610:3) " true\n " --> (332:18-333:3) " true\n\t\t" -(610:3-610:4) "}" --> (333:3-333:5) "\t}" -(610:4-611:1) ");\n" --> (333:5-334:2) ");\n\t" -(611:1-613:0) "}\n" --> (334:2-335:2) "\t}\n\t" -(613:0-613:9) "\nfunction" --> (335:2-335:11) "\tfunction" -(613:9-613:46) " warnIfStringRefCannotBeAutoConverted" --> (335:11-335:48) " warnIfStringRefCannotBeAutoConverted" -(613:46-613:54) "(config)" --> (335:48-335:56) "(config)" -(613:54-614:2) " {\n " --> (335:56-336:3) " {\n\t\t" -(614:2-615:4) " {\n " --> (336:3-337:0) "\t{" -(615:4-615:15) " if (typeof" --> (337:0-337:15) "\n\t\t\t\tif (typeof" -(615:15-615:22) " config" --> (337:15-337:22) " config" -(615:22-615:30) ".ref ===" --> (337:22-337:30) ".ref ===" -(615:30-615:42) " 'string' &&" --> (337:30-337:42) " \"string\" &&" -(615:42-615:60) " ReactCurrentOwner" --> (337:42-337:60) " ReactCurrentOwner" -(615:60-615:71) ".current &&" --> (337:60-337:71) ".current &&" -(615:71-615:78) " config" --> (337:71-337:78) " config" -(615:78-615:88) ".__self &&" --> (337:78-337:88) ".__self &&" -(615:88-615:106) " ReactCurrentOwner" --> (337:88-337:106) " ReactCurrentOwner" -(615:106-615:114) ".current" --> (337:106-337:114) ".current" -(615:114-615:128) ".stateNode !==" --> (337:114-337:128) ".stateNode !==" -(615:128-615:135) " config" --> (337:128-337:135) " config" -(615:135-615:143) ".__self)" --> (337:135-337:143) ".__self)" -(615:143-616:6) " {\n " --> (337:143-338:5) " {\n\t\t\t\t" -(616:6-616:10) " var" --> (338:5-338:9) "\tvar" -(616:10-616:26) " componentName =" --> (338:9-338:25) " componentName =" -(616:26-616:43) " getComponentName" --> (338:25-338:42) " getComponentName" -(616:43-616:61) "(ReactCurrentOwner" --> (338:42-338:60) "(ReactCurrentOwner" -(616:61-616:69) ".current" --> (338:60-338:68) ".current" -(616:69-616:74) ".type" --> (338:68-338:73) ".type" -(616:74-618:6) ");\n\n " --> (338:73-339:0) ");" -(618:6-618:11) " if (" --> (339:0-339:10) "\n\t\t\t\t\tif (" -(618:11-618:34) "!didWarnAboutStringRefs" --> (339:10-339:33) "!didWarnAboutStringRefs" -(618:34-618:50) "[componentName])" --> (339:33-339:49) "[componentName])" -(618:50-619:8) " {\n " --> (339:49-340:0) " {" -(619:8-619:14) " error" --> (340:0-340:12) "\n\t\t\t\t\t\terror" -(619:14-619:64) "('Component \"%s\" contains the string ref \"%s\". ' +" --> (340:12-340:66) "(\"Component \\\"%s\\\" contains the string ref \\\"%s\\\". \" +" -(619:64-619:136) " 'Support for string refs will be removed in a future major release. ' +" --> (340:66-340:138) " \"Support for string refs will be removed in a future major release. \" +" -(619:136-619:207) " 'This case cannot be automatically converted to an arrow function. ' +" --> (340:138-340:209) " \"This case cannot be automatically converted to an arrow function. \" +" -(619:207-619:291) " 'We ask you to manually fix this case by using useRef() or createRef() instead. ' +" --> (340:209-340:293) " \"We ask you to manually fix this case by using useRef() or createRef() instead. \" +" -(619:291-619:337) " 'Learn more about using refs safely here: ' +" --> (340:293-340:339) " \"Learn more about using refs safely here: \" +" -(619:337-619:388) " 'https://reactjs.org/link/strict-mode-string-ref'," --> (340:339-340:390) " \"https://reactjs.org/link/strict-mode-string-ref\"," -(619:388-619:403) " componentName," --> (340:390-340:405) " componentName," -(619:403-619:410) " config" --> (340:405-340:412) " config" -(619:410-619:414) ".ref" --> (340:412-340:416) ".ref" -(619:414-621:8) ");\n\n " --> (340:416-341:0) ");" -(621:8-621:31) " didWarnAboutStringRefs" --> (341:0-341:29) "\n\t\t\t\t\t\tdidWarnAboutStringRefs" -(621:31-621:48) "[componentName] =" --> (341:29-341:46) "[componentName] =" -(621:48-622:7) " true;\n " --> (341:46-342:5) " true;\n\t\t\t\t" -(622:7-623:5) "}\n " --> (342:5-343:4) "\t}\n\t\t\t" -(623:5-624:3) "}\n " --> (343:4-344:3) "\t}\n\t\t" -(624:3-625:1) "}\n" --> (344:3-345:2) "\t}\n\t" -(625:1-648:0) "}\n/**\n * Factory method to create a new React element. This no longer adheres to\n * the class pattern, so do not use new to call it. Also, instanceof check\n * will not work. Instead test $$typeof field against Symbol.for('react.element') to check\n * if something is a React Element.\n *\n * @param {*} type\n * @param {*} props\n * @param {*} key\n * @param {string|object} ref\n * @param {*} owner\n * @param {*} self A *temporary* helper to detect places where `this` is\n * different from the `owner` when React.createElement is called, so that we\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\n * functions, and as long as `this` and owner are the same, there will be no\n * change in behavior.\n * @param {*} source An annotation object (added by a transpiler or otherwise)\n * indicating filename, line number, and/or other information.\n * @internal\n */\n\n" --> (345:2-346:2) "\t}\n\t" -(648:0-648:4) "\nvar" --> (346:2-346:6) "\tvar" -(648:4-648:19) " ReactElement =" --> (346:6-346:21) " ReactElement =" -(648:19-648:29) " function " --> (346:21-346:30) " function" -(648:29-648:35) "(type," --> (346:30-346:36) "(type," -(648:35-648:40) " key," --> (346:36-346:41) " key," -(648:40-648:45) " ref," --> (346:41-346:46) " ref," -(648:45-648:51) " self," --> (346:46-346:52) " self," -(648:51-648:59) " source," --> (346:52-346:60) " source," -(648:59-648:66) " owner," --> (346:60-346:67) " owner," -(648:66-648:73) " props)" --> (346:67-346:74) " props)" -(648:73-649:2) " {\n " --> (346:74-347:3) " {\n\t\t" -(649:2-649:6) " var" --> (347:3-347:7) "\tvar" -(649:6-649:16) " element =" --> (347:7-347:17) " element =" -(649:16-651:4) " {\n // This tag allows us to uniquely identify this as a React Element\n " --> (347:17-348:4) " {\n\t\t\t" -(651:4-651:14) " $$typeof:" --> (348:4-348:14) "\t$$typeof:" -(651:14-653:10) " REACT_ELEMENT_TYPE,\n // Built-in properties that belong on the element\n type:" --> (348:14-349:4) " REACT_ELEMENT_TYPE,\n\t\t\t" -(653:10-654:9) " type,\n key:" --> (349:4-350:4) "\ttype,\n\t\t\t" -(654:9-655:9) " key,\n ref:" --> (350:4-351:4) "\tkey,\n\t\t\t" -(655:9-656:11) " ref,\n props:" --> (351:4-352:4) "\tref,\n\t\t\t" -(656:11-658:4) " props,\n // Record the component responsible for creating this element.\n " --> (352:4-353:4) "\tprops,\n\t\t\t" -(658:4-658:12) " _owner:" --> (353:4-353:12) "\t_owner:" -(658:12-659:3) " owner\n " --> (353:12-354:3) " owner\n\t\t" -(659:3-661:2) "};\n\n " --> (354:3-355:3) "\t};\n\t\t" -(661:2-666:4) " {\n // The validation flag is currently mutative. We put it on\n // an external backing store so that we can freeze the whole object.\n // This can be replaced with a WeakMap once they are implemented in\n // commonly used development environments.\n " --> (355:3-356:0) "\t{" -(666:4-666:12) " element" --> (356:0-356:12) "\n\t\t\t\telement" -(666:12-666:21) "._store =" --> (356:12-356:21) "._store =" -(666:21-666:23) " {" --> (356:21-356:22) " " -(666:23-671:4) "}; // To make comparing ReactElements easier for testing purposes, we make\n // the validation flag non-enumerable (where possible, which should\n // include every environment we run tests in), so the test framework\n // ignores it.\n\n " --> (356:22-357:0) "{};" -(671:4-671:11) " Object" --> (357:0-357:11) "\n\t\t\t\tObject" -(671:11-671:26) ".defineProperty" --> (357:11-357:26) ".defineProperty" -(671:26-671:34) "(element" --> (357:26-357:34) "(element" -(671:34-671:42) "._store," --> (357:34-357:42) "._store," -(671:42-671:55) " 'validated'," --> (357:42-357:55) " \"validated\"," -(671:55-672:6) " {\n " --> (357:55-358:5) " {\n\t\t\t\t" -(672:6-672:20) " configurable:" --> (358:5-358:19) "\tconfigurable:" -(672:20-673:6) " false,\n " --> (358:19-359:5) " false,\n\t\t\t\t" -(673:6-673:18) " enumerable:" --> (359:5-359:17) "\tenumerable:" -(673:18-674:6) " false,\n " --> (359:17-360:5) " false,\n\t\t\t\t" -(674:6-674:16) " writable:" --> (360:5-360:15) "\twritable:" -(674:16-675:6) " true,\n " --> (360:15-361:5) " true,\n\t\t\t\t" -(675:6-675:13) " value:" --> (361:5-361:12) "\tvalue:" -(675:13-676:5) " false\n " --> (361:12-362:4) " false\n\t\t\t" -(676:5-676:6) "}" --> (362:4-362:6) "\t}" -(676:6-678:4) "); // self and source are DEV only properties.\n\n " --> (362:6-363:0) ");" -(678:4-678:11) " Object" --> (363:0-363:11) "\n\t\t\t\tObject" -(678:11-678:26) ".defineProperty" --> (363:11-363:26) ".defineProperty" -(678:26-678:35) "(element," --> (363:26-363:35) "(element," -(678:35-678:44) " '_self'," --> (363:35-363:44) " \"_self\"," -(678:44-679:6) " {\n " --> (363:44-364:5) " {\n\t\t\t\t" -(679:6-679:20) " configurable:" --> (364:5-364:19) "\tconfigurable:" -(679:20-680:6) " false,\n " --> (364:19-365:5) " false,\n\t\t\t\t" -(680:6-680:18) " enumerable:" --> (365:5-365:17) "\tenumerable:" -(680:18-681:6) " false,\n " --> (365:17-366:5) " false,\n\t\t\t\t" -(681:6-681:16) " writable:" --> (366:5-366:15) "\twritable:" -(681:16-682:6) " false,\n " --> (366:15-367:5) " false,\n\t\t\t\t" -(682:6-682:13) " value:" --> (367:5-367:12) "\tvalue:" -(682:13-683:5) " self\n " --> (367:12-368:4) " self\n\t\t\t" -(683:5-683:6) "}" --> (368:4-368:6) "\t}" -(683:6-686:4) "); // Two elements created in two different places should be considered\n // equal for testing purposes and therefore we hide it from enumeration.\n\n " --> (368:6-369:0) ");" -(686:4-686:11) " Object" --> (369:0-369:11) "\n\t\t\t\tObject" -(686:11-686:26) ".defineProperty" --> (369:11-369:26) ".defineProperty" -(686:26-686:35) "(element," --> (369:26-369:35) "(element," -(686:35-686:46) " '_source'," --> (369:35-369:46) " \"_source\"," -(686:46-687:6) " {\n " --> (369:46-370:5) " {\n\t\t\t\t" -(687:6-687:20) " configurable:" --> (370:5-370:19) "\tconfigurable:" -(687:20-688:6) " false,\n " --> (370:19-371:5) " false,\n\t\t\t\t" -(688:6-688:18) " enumerable:" --> (371:5-371:17) "\tenumerable:" -(688:18-689:6) " false,\n " --> (371:17-372:5) " false,\n\t\t\t\t" -(689:6-689:16) " writable:" --> (372:5-372:15) "\twritable:" -(689:16-690:6) " false,\n " --> (372:15-373:5) " false,\n\t\t\t\t" -(690:6-690:13) " value:" --> (373:5-373:12) "\tvalue:" -(690:13-691:5) " source\n " --> (373:12-374:4) " source\n\t\t\t" -(691:5-691:6) "}" --> (374:4-374:6) "\t}" -(691:6-693:4) ");\n\n " --> (374:6-375:0) ");" -(693:4-693:8) " if " --> (375:0-375:8) "\n\t\t\t\tif " -(693:8-693:15) "(Object" --> (375:8-375:15) "(Object" -(693:15-693:23) ".freeze)" --> (375:15-375:23) ".freeze)" -(693:23-694:6) " {\n " --> (375:23-376:0) " {" -(694:6-694:13) " Object" --> (376:0-376:12) "\n\t\t\t\t\tObject" -(694:13-694:20) ".freeze" --> (376:12-376:19) ".freeze" -(694:20-694:28) "(element" --> (376:19-376:27) "(element" -(694:28-694:34) ".props" --> (376:27-376:33) ".props" -(694:34-695:6) ");\n " --> (376:33-377:0) ");" -(695:6-695:13) " Object" --> (377:0-377:12) "\n\t\t\t\t\tObject" -(695:13-695:20) ".freeze" --> (377:12-377:19) ".freeze" -(695:20-695:28) "(element" --> (377:19-377:27) "(element" -(695:28-696:5) ");\n " --> (377:27-378:4) ");\n\t\t\t" -(696:5-697:3) "}\n " --> (378:4-379:3) "\t}\n\t\t" -(697:3-699:2) "}\n\n " --> (379:3-380:0) "\t}" -(699:2-699:9) " return" --> (380:0-380:10) "\n\t\t\treturn" -(699:9-700:1) " element;\n" --> (380:10-381:2) " element;\n\t" -(700:1-706:0) "};\n/**\n * Create and return a new ReactElement of the given type.\n * See https://reactjs.org/docs/react-api.html#createelement\n */\n" --> (381:2-382:2) "\t};\n\t" -(706:0-706:9) "\nfunction" --> (382:2-382:11) "\tfunction" -(706:9-706:23) " createElement" --> (382:11-382:25) " createElement" -(706:23-706:29) "(type," --> (382:25-382:31) "(type," -(706:29-706:37) " config," --> (382:31-382:39) " config," -(706:37-706:47) " children)" --> (382:39-382:49) " children)" -(706:47-707:2) " {\n " --> (382:49-383:3) " {\n\t\t" -(707:2-707:6) " var" --> (383:3-383:7) "\tvar" -(707:6-709:2) " propName; // Reserved names are extracted\n\n " --> (383:7-384:3) " propName;\n\t\t" -(709:2-709:6) " var" --> (384:3-384:7) "\tvar" -(709:6-709:14) " props =" --> (384:7-384:15) " props =" -(709:14-709:16) " {" --> (384:15-384:16) " " -(709:16-710:2) "};\n " --> (384:16-385:3) "{};\n\t\t" -(710:2-710:6) " var" --> (385:3-385:7) "\tvar" -(710:6-710:12) " key =" --> (385:7-385:13) " key =" -(710:12-711:2) " null;\n " --> (385:13-386:3) " null;\n\t\t" -(711:2-711:6) " var" --> (386:3-386:7) "\tvar" -(711:6-711:12) " ref =" --> (386:7-386:13) " ref =" -(711:12-712:2) " null;\n " --> (386:13-387:3) " null;\n\t\t" -(712:2-712:6) " var" --> (387:3-387:7) "\tvar" -(712:6-712:13) " self =" --> (387:7-387:14) " self =" -(712:13-713:2) " null;\n " --> (387:14-388:3) " null;\n\t\t" -(713:2-713:6) " var" --> (388:3-388:7) "\tvar" -(713:6-713:15) " source =" --> (388:7-388:16) " source =" -(713:15-715:2) " null;\n\n " --> (388:16-389:0) " null;" -(715:2-715:6) " if " --> (389:0-389:7) "\n\t\t\tif " -(715:6-715:16) "(config !=" --> (389:7-389:17) "(config !=" -(715:16-715:22) " null)" --> (389:17-389:23) " null)" -(715:22-716:4) " {\n " --> (389:23-390:0) " {" -(716:4-716:8) " if " --> (390:0-390:8) "\n\t\t\t\tif " -(716:8-716:20) "(hasValidRef" --> (390:8-390:20) "(hasValidRef" -(716:20-716:27) "(config" --> (390:20-390:27) "(config" -(716:27-716:29) "))" --> (390:27-390:29) "))" -(716:29-717:6) " {\n " --> (390:29-391:0) " {" -(717:6-717:12) " ref =" --> (391:0-391:11) "\n\t\t\t\t\tref =" -(717:12-717:19) " config" --> (391:11-391:18) " config" -(717:19-719:6) ".ref;\n\n " --> (391:18-392:5) ".ref;\n\t\t\t\t" -(719:6-720:8) " {\n " --> (392:5-393:0) "\t{" -(720:8-720:45) " warnIfStringRefCannotBeAutoConverted" --> (393:0-393:43) "\n\t\t\t\t\t\twarnIfStringRefCannotBeAutoConverted" -(720:45-720:52) "(config" --> (393:43-393:50) "(config" -(720:52-721:7) ");\n " --> (393:50-394:5) ");\n\t\t\t\t" -(721:7-722:5) "}\n " --> (394:5-395:4) "\t}\n\t\t\t" -(722:5-724:4) "}\n\n " --> (395:4-396:0) "\t}" -(724:4-724:8) " if " --> (396:0-396:8) "\n\t\t\t\tif " -(724:8-724:20) "(hasValidKey" --> (396:8-396:20) "(hasValidKey" -(724:20-724:27) "(config" --> (396:20-396:27) "(config" -(724:27-724:29) "))" --> (396:27-396:29) "))" -(724:29-725:6) " {\n " --> (396:29-397:0) " {" -(725:6-725:12) " key =" --> (397:0-397:11) "\n\t\t\t\t\tkey =" -(725:12-725:17) " '' +" --> (397:11-397:16) " \"\" +" -(725:17-725:24) " config" --> (397:16-397:23) " config" -(725:24-726:5) ".key;\n " --> (397:23-398:4) ".key;\n\t\t\t" -(726:5-728:4) "}\n\n " --> (398:4-399:0) "\t}" -(728:4-728:11) " self =" --> (399:0-399:11) "\n\t\t\t\tself =" -(728:11-728:18) " config" --> (399:11-399:18) " config" -(728:18-728:29) ".__self ===" --> (399:18-399:29) ".__self ===" -(728:29-728:41) " undefined ?" --> (399:29-399:41) " undefined ?" -(728:41-728:48) " null :" --> (399:41-399:48) " null :" -(728:48-728:55) " config" --> (399:48-399:55) " config" -(728:55-729:4) ".__self;\n " --> (399:55-400:0) ".__self;" -(729:4-729:13) " source =" --> (400:0-400:13) "\n\t\t\t\tsource =" -(729:13-729:20) " config" --> (400:13-400:20) " config" -(729:20-729:33) ".__source ===" --> (400:20-400:33) ".__source ===" -(729:33-729:45) " undefined ?" --> (400:33-400:45) " undefined ?" -(729:45-729:52) " null :" --> (400:45-400:52) " null :" -(729:52-729:59) " config" --> (400:52-400:59) " config" -(729:59-731:4) ".__source; // Remaining properties are added to a new props object\n\n " --> (400:59-401:0) ".__source;" -(731:4-731:9) " for " --> (401:0-401:9) "\n\t\t\t\tfor " -(731:9-731:21) "(propName in" --> (401:9-401:21) "(propName in" -(731:21-731:29) " config)" --> (401:21-401:29) " config)" -(731:29-732:6) " {\n " --> (401:29-402:0) " {" -(732:6-732:10) " if " --> (402:0-402:9) "\n\t\t\t\t\tif " -(732:10-732:25) "(hasOwnProperty" --> (402:9-402:24) "(hasOwnProperty" -(732:25-732:30) ".call" --> (402:24-402:29) ".call" -(732:30-732:38) "(config," --> (402:29-402:37) "(config," -(732:38-732:47) " propName" --> (402:37-402:46) " propName" -(732:47-732:52) ") && " --> (402:46-402:51) ") && " -(732:52-732:67) "!RESERVED_PROPS" --> (402:51-402:66) "!RESERVED_PROPS" -(732:67-732:82) ".hasOwnProperty" --> (402:66-402:81) ".hasOwnProperty" -(732:82-732:91) "(propName" --> (402:81-402:90) "(propName" -(732:91-732:93) "))" --> (402:90-402:92) "))" -(732:93-733:8) " {\n " --> (402:92-403:0) " {" -(733:8-733:14) " props" --> (403:0-403:12) "\n\t\t\t\t\t\tprops" -(733:14-733:26) "[propName] =" --> (403:12-403:24) "[propName] =" -(733:26-733:33) " config" --> (403:24-403:31) " config" -(733:33-734:7) "[propName];\n " --> (403:31-404:5) "[propName];\n\t\t\t\t" -(734:7-735:5) "}\n " --> (404:5-405:4) "\t}\n\t\t\t" -(735:5-736:3) "}\n " --> (405:4-406:3) "\t}\n\t\t" -(736:3-740:2) "} // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n\n\n " --> (406:3-407:3) "\t}\n\t\t" -(740:2-740:6) " var" --> (407:3-407:7) "\tvar" -(740:6-740:23) " childrenLength =" --> (407:7-407:24) " childrenLength =" -(740:23-740:33) " arguments" --> (407:24-407:34) " arguments" -(740:33-740:42) ".length -" --> (407:34-407:43) ".length -" -(740:42-742:2) " 2;\n\n " --> (407:43-408:0) " 2;" -(742:2-742:6) " if " --> (408:0-408:7) "\n\t\t\tif " -(742:6-742:25) "(childrenLength ===" --> (408:7-408:26) "(childrenLength ===" -(742:25-742:28) " 1)" --> (408:26-408:29) " 1)" -(742:28-743:4) " {\n " --> (408:29-409:0) " {" -(743:4-743:10) " props" --> (409:0-409:10) "\n\t\t\t\tprops" -(743:10-743:21) ".children =" --> (409:10-409:21) ".children =" -(743:21-744:3) " children;\n " --> (409:21-410:3) " children;\n\t\t" -(744:3-744:13) "} else if " --> (410:3-410:14) "\t} else if " -(744:13-744:30) "(childrenLength >" --> (410:14-410:31) "(childrenLength >" -(744:30-744:33) " 1)" --> (410:31-410:34) " 1)" -(744:33-745:4) " {\n " --> (410:34-411:4) " {\n\t\t\t" -(745:4-745:8) " var" --> (411:4-411:8) "\tvar" -(745:8-745:21) " childArray =" --> (411:8-411:21) " childArray =" -(745:21-745:27) " Array" --> (411:21-411:27) " Array" -(745:27-745:42) "(childrenLength" --> (411:27-411:42) "(childrenLength" -(745:42-747:4) ");\n\n " --> (411:42-412:0) ");" -(747:4-747:9) " for " --> (412:0-412:9) "\n\t\t\t\tfor " -(747:9-747:13) "(var" --> (412:9-412:13) "(var" -(747:13-747:17) " i =" --> (412:13-412:17) " i =" -(747:17-747:20) " 0;" --> (412:17-412:20) " 0;" -(747:20-747:24) " i <" --> (412:20-412:24) " i <" -(747:24-747:40) " childrenLength;" --> (412:24-412:40) " childrenLength;" -(747:40-747:45) " i++)" --> (412:40-412:45) " i++)" -(747:45-748:6) " {\n " --> (412:45-413:0) " {" -(748:6-748:17) " childArray" --> (413:0-413:16) "\n\t\t\t\t\tchildArray" -(748:17-748:22) "[i] =" --> (413:16-413:21) "[i] =" -(748:22-748:32) " arguments" --> (413:21-413:31) " arguments" -(748:32-748:36) "[i +" --> (413:31-413:35) "[i +" -(748:36-749:5) " 2];\n " --> (413:35-414:4) " 2];\n\t\t\t" -(749:5-751:4) "}\n\n " --> (414:4-415:4) "\t}\n\t\t\t" -(751:4-752:6) " {\n " --> (415:4-416:0) "\t{" -(752:6-752:10) " if " --> (416:0-416:9) "\n\t\t\t\t\tif " -(752:10-752:17) "(Object" --> (416:9-416:16) "(Object" -(752:17-752:25) ".freeze)" --> (416:16-416:24) ".freeze)" -(752:25-753:8) " {\n " --> (416:24-417:0) " {" -(753:8-753:15) " Object" --> (417:0-417:13) "\n\t\t\t\t\t\tObject" -(753:15-753:22) ".freeze" --> (417:13-417:20) ".freeze" -(753:22-753:33) "(childArray" --> (417:20-417:31) "(childArray" -(753:33-754:7) ");\n " --> (417:31-418:5) ");\n\t\t\t\t" -(754:7-755:5) "}\n " --> (418:5-419:4) "\t}\n\t\t\t" -(755:5-757:4) "}\n\n " --> (419:4-420:0) "\t}" -(757:4-757:10) " props" --> (420:0-420:10) "\n\t\t\t\tprops" -(757:10-757:21) ".children =" --> (420:10-420:21) ".children =" -(757:21-758:3) " childArray;\n " --> (420:21-421:3) " childArray;\n\t\t" -(758:3-761:2) "} // Resolve default props\n\n\n " --> (421:3-422:0) "\t}" -(761:2-761:6) " if " --> (422:0-422:7) "\n\t\t\tif " -(761:6-761:14) "(type &&" --> (422:7-422:15) "(type &&" -(761:14-761:19) " type" --> (422:15-422:20) " type" -(761:19-761:33) ".defaultProps)" --> (422:20-422:34) ".defaultProps)" -(761:33-762:4) " {\n " --> (422:34-423:4) " {\n\t\t\t" -(762:4-762:8) " var" --> (423:4-423:8) "\tvar" -(762:8-762:23) " defaultProps =" --> (423:8-423:23) " defaultProps =" -(762:23-762:28) " type" --> (423:23-423:28) " type" -(762:28-764:4) ".defaultProps;\n\n " --> (423:28-424:0) ".defaultProps;" -(764:4-764:9) " for " --> (424:0-424:9) "\n\t\t\t\tfor " -(764:9-764:21) "(propName in" --> (424:9-424:21) "(propName in" -(764:21-764:35) " defaultProps)" --> (424:21-424:35) " defaultProps)" -(764:35-765:6) " {\n " --> (424:35-425:0) " {" -(765:6-765:10) " if " --> (425:0-425:9) "\n\t\t\t\t\tif " -(765:10-765:16) "(props" --> (425:9-425:15) "(props" -(765:16-765:30) "[propName] ===" --> (425:15-425:29) "[propName] ===" -(765:30-765:41) " undefined)" --> (425:29-425:40) " undefined)" -(765:41-766:8) " {\n " --> (425:40-426:0) " {" -(766:8-766:14) " props" --> (426:0-426:12) "\n\t\t\t\t\t\tprops" -(766:14-766:26) "[propName] =" --> (426:12-426:24) "[propName] =" -(766:26-766:39) " defaultProps" --> (426:24-426:37) " defaultProps" -(766:39-767:7) "[propName];\n " --> (426:37-427:5) "[propName];\n\t\t\t\t" -(767:7-768:5) "}\n " --> (427:5-428:4) "\t}\n\t\t\t" -(768:5-769:3) "}\n " --> (428:4-429:3) "\t}\n\t\t" -(769:3-771:2) "}\n\n " --> (429:3-430:3) "\t}\n\t\t" -(771:2-772:4) " {\n " --> (430:3-431:0) "\t{" -(772:4-772:8) " if " --> (431:0-431:8) "\n\t\t\t\tif " -(772:8-772:15) "(key ||" --> (431:8-431:15) "(key ||" -(772:15-772:20) " ref)" --> (431:15-431:20) " ref)" -(772:20-773:6) " {\n " --> (431:20-432:5) " {\n\t\t\t\t" -(773:6-773:10) " var" --> (432:5-432:9) "\tvar" -(773:10-773:31) " displayName = typeof" --> (432:9-432:30) " displayName = typeof" -(773:31-773:40) " type ===" --> (432:30-432:39) " type ===" -(773:40-773:53) " 'function' ?" --> (432:39-432:52) " \"function\" ?" -(773:53-773:58) " type" --> (432:52-432:57) " type" -(773:58-773:73) ".displayName ||" --> (432:57-432:72) ".displayName ||" -(773:73-773:78) " type" --> (432:72-432:77) " type" -(773:78-773:86) ".name ||" --> (432:77-432:85) ".name ||" -(773:86-773:98) " 'Unknown' :" --> (432:85-432:97) " \"Unknown\" :" -(773:98-775:6) " type;\n\n " --> (432:97-433:0) " type;" -(775:6-775:10) " if " --> (433:0-433:9) "\n\t\t\t\t\tif " -(775:10-775:15) "(key)" --> (433:9-433:14) "(key)" -(775:15-776:8) " {\n " --> (433:14-434:0) " {" -(776:8-776:35) " defineKeyPropWarningGetter" --> (434:0-434:33) "\n\t\t\t\t\t\tdefineKeyPropWarningGetter" -(776:35-776:42) "(props," --> (434:33-434:40) "(props," -(776:42-776:54) " displayName" --> (434:40-434:52) " displayName" -(776:54-777:7) ");\n " --> (434:52-435:5) ");\n\t\t\t\t" -(777:7-779:6) "}\n\n " --> (435:5-436:0) "\t}" -(779:6-779:10) " if " --> (436:0-436:9) "\n\t\t\t\t\tif " -(779:10-779:15) "(ref)" --> (436:9-436:14) "(ref)" -(779:15-780:8) " {\n " --> (436:14-437:0) " {" -(780:8-780:35) " defineRefPropWarningGetter" --> (437:0-437:33) "\n\t\t\t\t\t\tdefineRefPropWarningGetter" -(780:35-780:42) "(props," --> (437:33-437:40) "(props," -(780:42-780:54) " displayName" --> (437:40-437:52) " displayName" -(780:54-781:7) ");\n " --> (437:52-438:5) ");\n\t\t\t\t" -(781:7-782:5) "}\n " --> (438:5-439:4) "\t}\n\t\t\t" -(782:5-783:3) "}\n " --> (439:4-440:3) "\t}\n\t\t" -(783:3-785:2) "}\n\n " --> (440:3-441:0) "\t}" -(785:2-785:9) " return" --> (441:0-441:10) "\n\t\t\treturn" -(785:9-785:22) " ReactElement" --> (441:10-441:23) " ReactElement" -(785:22-785:28) "(type," --> (441:23-441:29) "(type," -(785:28-785:33) " key," --> (441:29-441:34) " key," -(785:33-785:38) " ref," --> (441:34-441:39) " ref," -(785:38-785:44) " self," --> (441:39-441:45) " self," -(785:44-785:52) " source," --> (441:45-441:53) " source," -(785:52-785:70) " ReactCurrentOwner" --> (441:53-441:71) " ReactCurrentOwner" -(785:70-785:79) ".current," --> (441:71-441:80) ".current," -(785:79-785:85) " props" --> (441:80-441:86) " props" -(785:85-786:1) ");\n" --> (441:86-442:2) ");\n\t" -(786:1-787:0) "}" --> (442:2-443:2) "\t}\n\t" -(787:0-787:9) "\nfunction" --> (443:2-443:11) "\tfunction" -(787:9-787:28) " cloneAndReplaceKey" --> (443:11-443:30) " cloneAndReplaceKey" -(787:28-787:40) "(oldElement," --> (443:30-443:42) "(oldElement," -(787:40-787:48) " newKey)" --> (443:42-443:50) " newKey)" -(787:48-788:2) " {\n " --> (443:50-444:3) " {\n\t\t" -(788:2-788:6) " var" --> (444:3-444:7) "\tvar" -(788:6-788:19) " newElement =" --> (444:7-444:20) " newElement =" -(788:19-788:32) " ReactElement" --> (444:20-444:33) " ReactElement" -(788:32-788:43) "(oldElement" --> (444:33-444:44) "(oldElement" -(788:43-788:49) ".type," --> (444:44-444:50) ".type," -(788:49-788:57) " newKey," --> (444:50-444:58) " newKey," -(788:57-788:68) " oldElement" --> (444:58-444:69) " oldElement" -(788:68-788:73) ".ref," --> (444:69-444:74) ".ref," -(788:73-788:84) " oldElement" --> (444:74-444:85) " oldElement" -(788:84-788:91) "._self," --> (444:85-444:92) "._self," -(788:91-788:102) " oldElement" --> (444:92-444:103) " oldElement" -(788:102-788:111) "._source," --> (444:103-444:112) "._source," -(788:111-788:122) " oldElement" --> (444:112-444:123) " oldElement" -(788:122-788:130) "._owner," --> (444:123-444:131) "._owner," -(788:130-788:141) " oldElement" --> (444:131-444:142) " oldElement" -(788:141-788:147) ".props" --> (444:142-444:148) ".props" -(788:147-789:2) ");\n " --> (444:148-445:0) ");" -(789:2-789:9) " return" --> (445:0-445:10) "\n\t\t\treturn" -(789:9-790:1) " newElement;\n" --> (445:10-446:2) " newElement;\n\t" -(790:1-796:0) "}\n/**\n * Clone and return a new ReactElement using element as the starting point.\n * See https://reactjs.org/docs/react-api.html#cloneelement\n */\n" --> (446:2-447:2) "\t}\n\t" -(796:0-796:9) "\nfunction" --> (447:2-447:11) "\tfunction" -(796:9-796:22) " cloneElement" --> (447:11-447:24) " cloneElement" -(796:22-796:31) "(element," --> (447:24-447:33) "(element," -(796:31-796:39) " config," --> (447:33-447:41) " config," -(796:39-796:49) " children)" --> (447:41-447:51) " children)" -(796:49-797:2) " {\n " --> (447:51-448:0) " {" -(797:2-797:9) " if (!!" --> (448:0-448:10) "\n\t\t\tif (!!" -(797:9-797:21) "(element ===" --> (448:10-448:22) "(element ===" -(797:21-797:29) " null ||" --> (448:22-448:30) " null ||" -(797:29-797:41) " element ===" --> (448:30-448:42) " element ===" -(797:41-797:53) " undefined))" --> (448:42-448:54) " undefined))" -(797:53-798:4) " {\n " --> (448:54-449:4) " {\n\t\t\t" -(798:4-799:6) " {\n " --> (449:4-450:0) "\t{" -(799:6-799:12) " throw" --> (450:0-450:11) "\n\t\t\t\t\tthrow" -(799:12-799:19) " Error(" --> (450:11-450:17) " Error" -(799:19-799:102) " \"React.cloneElement(...): The argument must be a React element, but you passed \" +" --> (450:17-450:100) "(\"React.cloneElement(...): The argument must be a React element, but you passed \" +" -(799:102-799:112) " element +" --> (450:100-450:110) " element +" -(799:112-799:117) " \".\" " --> (450:110-450:114) " \".\"" -(799:117-800:5) ");\n " --> (450:114-451:4) ");\n\t\t\t" -(800:5-801:3) "}\n " --> (451:4-452:3) "\t}\n\t\t" -(801:3-803:2) "}\n\n " --> (452:3-453:3) "\t}\n\t\t" -(803:2-803:6) " var" --> (453:3-453:7) "\tvar" -(803:6-805:2) " propName; // Original props are copied\n\n " --> (453:7-454:3) " propName;\n\t\t" -(805:2-805:6) " var" --> (454:3-454:7) "\tvar" -(805:6-805:14) " props =" --> (454:7-454:15) " props =" -(805:14-805:22) " _assign" --> (454:15-454:23) " _assign" -(805:22-805:24) "({" --> (454:23-454:24) "(" -(805:24-805:26) "}," --> (454:24-454:27) "{}," -(805:26-805:34) " element" --> (454:27-454:35) " element" -(805:34-805:40) ".props" --> (454:35-454:41) ".props" -(805:40-808:2) "); // Reserved names are extracted\n\n\n " --> (454:41-455:3) ");\n\t\t" -(808:2-808:6) " var" --> (455:3-455:7) "\tvar" -(808:6-808:12) " key =" --> (455:7-455:13) " key =" -(808:12-808:20) " element" --> (455:13-455:21) " element" -(808:20-809:2) ".key;\n " --> (455:21-456:3) ".key;\n\t\t" -(809:2-809:6) " var" --> (456:3-456:7) "\tvar" -(809:6-809:12) " ref =" --> (456:7-456:13) " ref =" -(809:12-809:20) " element" --> (456:13-456:21) " element" -(809:20-811:2) ".ref; // Self is preserved since the owner is preserved.\n\n " --> (456:21-457:3) ".ref;\n\t\t" -(811:2-811:6) " var" --> (457:3-457:7) "\tvar" -(811:6-811:13) " self =" --> (457:7-457:14) " self =" -(811:13-811:21) " element" --> (457:14-457:22) " element" -(811:21-815:2) "._self; // Source is preserved since cloneElement is unlikely to be targeted by a\n // transpiler, and the original source is probably a better indicator of the\n // true owner.\n\n " --> (457:22-458:3) "._self;\n\t\t" -(815:2-815:6) " var" --> (458:3-458:7) "\tvar" -(815:6-815:15) " source =" --> (458:7-458:16) " source =" -(815:15-815:23) " element" --> (458:16-458:24) " element" -(815:23-817:2) "._source; // Owner will be preserved, unless ref is overridden\n\n " --> (458:24-459:3) "._source;\n\t\t" -(817:2-817:6) " var" --> (459:3-459:7) "\tvar" -(817:6-817:14) " owner =" --> (459:7-459:15) " owner =" -(817:14-817:22) " element" --> (459:15-459:23) " element" -(817:22-819:2) "._owner;\n\n " --> (459:23-460:0) "._owner;" -(819:2-819:6) " if " --> (460:0-460:7) "\n\t\t\tif " -(819:6-819:16) "(config !=" --> (460:7-460:17) "(config !=" -(819:16-819:22) " null)" --> (460:17-460:23) " null)" -(819:22-820:4) " {\n " --> (460:23-461:0) " {" -(820:4-820:8) " if " --> (461:0-461:8) "\n\t\t\t\tif " -(820:8-820:20) "(hasValidRef" --> (461:8-461:20) "(hasValidRef" -(820:20-820:27) "(config" --> (461:20-461:27) "(config" -(820:27-820:29) "))" --> (461:27-461:29) "))" -(820:29-822:6) " {\n // Silently steal the ref from the parent.\n " --> (461:29-462:0) " {" -(822:6-822:12) " ref =" --> (462:0-462:11) "\n\t\t\t\t\tref =" -(822:12-822:19) " config" --> (462:11-462:18) " config" -(822:19-823:6) ".ref;\n " --> (462:18-463:0) ".ref;" -(823:6-823:14) " owner =" --> (463:0-463:13) "\n\t\t\t\t\towner =" -(823:14-823:32) " ReactCurrentOwner" --> (463:13-463:31) " ReactCurrentOwner" -(823:32-824:5) ".current;\n " --> (463:31-464:4) ".current;\n\t\t\t" -(824:5-826:4) "}\n\n " --> (464:4-465:0) "\t}" -(826:4-826:8) " if " --> (465:0-465:8) "\n\t\t\t\tif " -(826:8-826:20) "(hasValidKey" --> (465:8-465:20) "(hasValidKey" -(826:20-826:27) "(config" --> (465:20-465:27) "(config" -(826:27-826:29) "))" --> (465:27-465:29) "))" -(826:29-827:6) " {\n " --> (465:29-466:0) " {" -(827:6-827:12) " key =" --> (466:0-466:11) "\n\t\t\t\t\tkey =" -(827:12-827:17) " '' +" --> (466:11-466:16) " \"\" +" -(827:17-827:24) " config" --> (466:16-466:23) " config" -(827:24-828:5) ".key;\n " --> (466:23-467:4) ".key;\n\t\t\t" -(828:5-831:4) "} // Remaining properties override existing props\n\n\n " --> (467:4-468:4) "\t}\n\t\t\t" -(831:4-831:8) " var" --> (468:4-468:8) "\tvar" -(831:8-833:4) " defaultProps;\n\n " --> (468:8-469:0) " defaultProps;" -(833:4-833:8) " if " --> (469:0-469:8) "\n\t\t\t\tif " -(833:8-833:16) "(element" --> (469:8-469:16) "(element" -(833:16-833:24) ".type &&" --> (469:16-469:24) ".type &&" -(833:24-833:32) " element" --> (469:24-469:32) " element" -(833:32-833:37) ".type" --> (469:32-469:37) ".type" -(833:37-833:51) ".defaultProps)" --> (469:37-469:51) ".defaultProps)" -(833:51-834:6) " {\n " --> (469:51-470:0) " {" -(834:6-834:21) " defaultProps =" --> (470:0-470:20) "\n\t\t\t\t\tdefaultProps =" -(834:21-834:29) " element" --> (470:20-470:28) " element" -(834:29-834:34) ".type" --> (470:28-470:33) ".type" -(834:34-835:5) ".defaultProps;\n " --> (470:33-471:4) ".defaultProps;\n\t\t\t" -(835:5-837:4) "}\n\n " --> (471:4-472:0) "\t}" -(837:4-837:9) " for " --> (472:0-472:9) "\n\t\t\t\tfor " -(837:9-837:21) "(propName in" --> (472:9-472:21) "(propName in" -(837:21-837:29) " config)" --> (472:21-472:29) " config)" -(837:29-838:6) " {\n " --> (472:29-473:0) " {" -(838:6-838:10) " if " --> (473:0-473:9) "\n\t\t\t\t\tif " -(838:10-838:25) "(hasOwnProperty" --> (473:9-473:24) "(hasOwnProperty" -(838:25-838:30) ".call" --> (473:24-473:29) ".call" -(838:30-838:38) "(config," --> (473:29-473:37) "(config," -(838:38-838:47) " propName" --> (473:37-473:46) " propName" -(838:47-838:52) ") && " --> (473:46-473:51) ") && " -(838:52-838:67) "!RESERVED_PROPS" --> (473:51-473:66) "!RESERVED_PROPS" -(838:67-838:82) ".hasOwnProperty" --> (473:66-473:81) ".hasOwnProperty" -(838:82-838:91) "(propName" --> (473:81-473:90) "(propName" -(838:91-838:93) "))" --> (473:90-473:92) "))" -(838:93-839:8) " {\n " --> (473:92-474:0) " {" -(839:8-839:12) " if " --> (474:0-474:10) "\n\t\t\t\t\t\tif " -(839:12-839:19) "(config" --> (474:10-474:17) "(config" -(839:19-839:33) "[propName] ===" --> (474:17-474:31) "[propName] ===" -(839:33-839:46) " undefined &&" --> (474:31-474:44) " undefined &&" -(839:46-839:63) " defaultProps !==" --> (474:44-474:61) " defaultProps !==" -(839:63-839:74) " undefined)" --> (474:61-474:72) " undefined)" -(839:74-841:10) " {\n // Resolve default props\n " --> (474:72-475:0) " {" -(841:10-841:16) " props" --> (475:0-475:13) "\n\t\t\t\t\t\t\tprops" -(841:16-841:28) "[propName] =" --> (475:13-475:25) "[propName] =" -(841:28-841:41) " defaultProps" --> (475:25-475:38) " defaultProps" -(841:41-842:9) "[propName];\n " --> (475:38-476:6) "[propName];\n\t\t\t\t\t" -(842:9-842:15) "} else" --> (476:6-476:13) "\t} else" -(842:15-843:10) " {\n " --> (476:13-477:0) " {" -(843:10-843:16) " props" --> (477:0-477:13) "\n\t\t\t\t\t\t\tprops" -(843:16-843:28) "[propName] =" --> (477:13-477:25) "[propName] =" -(843:28-843:35) " config" --> (477:25-477:32) " config" -(843:35-844:9) "[propName];\n " --> (477:32-478:6) "[propName];\n\t\t\t\t\t" -(844:9-845:7) "}\n " --> (478:6-479:5) "\t}\n\t\t\t\t" -(845:7-846:5) "}\n " --> (479:5-480:4) "\t}\n\t\t\t" -(846:5-847:3) "}\n " --> (480:4-481:3) "\t}\n\t\t" -(847:3-851:2) "} // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n\n\n " --> (481:3-482:3) "\t}\n\t\t" -(851:2-851:6) " var" --> (482:3-482:7) "\tvar" -(851:6-851:23) " childrenLength =" --> (482:7-482:24) " childrenLength =" -(851:23-851:33) " arguments" --> (482:24-482:34) " arguments" -(851:33-851:42) ".length -" --> (482:34-482:43) ".length -" -(851:42-853:2) " 2;\n\n " --> (482:43-483:0) " 2;" -(853:2-853:6) " if " --> (483:0-483:7) "\n\t\t\tif " -(853:6-853:25) "(childrenLength ===" --> (483:7-483:26) "(childrenLength ===" -(853:25-853:28) " 1)" --> (483:26-483:29) " 1)" -(853:28-854:4) " {\n " --> (483:29-484:0) " {" -(854:4-854:10) " props" --> (484:0-484:10) "\n\t\t\t\tprops" -(854:10-854:21) ".children =" --> (484:10-484:21) ".children =" -(854:21-855:3) " children;\n " --> (484:21-485:3) " children;\n\t\t" -(855:3-855:13) "} else if " --> (485:3-485:14) "\t} else if " -(855:13-855:30) "(childrenLength >" --> (485:14-485:31) "(childrenLength >" -(855:30-855:33) " 1)" --> (485:31-485:34) " 1)" -(855:33-856:4) " {\n " --> (485:34-486:4) " {\n\t\t\t" -(856:4-856:8) " var" --> (486:4-486:8) "\tvar" -(856:8-856:21) " childArray =" --> (486:8-486:21) " childArray =" -(856:21-856:27) " Array" --> (486:21-486:27) " Array" -(856:27-856:42) "(childrenLength" --> (486:27-486:42) "(childrenLength" -(856:42-858:4) ");\n\n " --> (486:42-487:0) ");" -(858:4-858:9) " for " --> (487:0-487:9) "\n\t\t\t\tfor " -(858:9-858:13) "(var" --> (487:9-487:13) "(var" -(858:13-858:17) " i =" --> (487:13-487:17) " i =" -(858:17-858:20) " 0;" --> (487:17-487:20) " 0;" -(858:20-858:24) " i <" --> (487:20-487:24) " i <" -(858:24-858:40) " childrenLength;" --> (487:24-487:40) " childrenLength;" -(858:40-858:45) " i++)" --> (487:40-487:45) " i++)" -(858:45-859:6) " {\n " --> (487:45-488:0) " {" -(859:6-859:17) " childArray" --> (488:0-488:16) "\n\t\t\t\t\tchildArray" -(859:17-859:22) "[i] =" --> (488:16-488:21) "[i] =" -(859:22-859:32) " arguments" --> (488:21-488:31) " arguments" -(859:32-859:36) "[i +" --> (488:31-488:35) "[i +" -(859:36-860:5) " 2];\n " --> (488:35-489:4) " 2];\n\t\t\t" -(860:5-862:4) "}\n\n " --> (489:4-490:0) "\t}" -(862:4-862:10) " props" --> (490:0-490:10) "\n\t\t\t\tprops" -(862:10-862:21) ".children =" --> (490:10-490:21) ".children =" -(862:21-863:3) " childArray;\n " --> (490:21-491:3) " childArray;\n\t\t" -(863:3-865:2) "}\n\n " --> (491:3-492:0) "\t}" -(865:2-865:9) " return" --> (492:0-492:10) "\n\t\t\treturn" -(865:9-865:22) " ReactElement" --> (492:10-492:23) " ReactElement" -(865:22-865:30) "(element" --> (492:23-492:31) "(element" -(865:30-865:36) ".type," --> (492:31-492:37) ".type," -(865:36-865:41) " key," --> (492:37-492:42) " key," -(865:41-865:46) " ref," --> (492:42-492:47) " ref," -(865:46-865:52) " self," --> (492:47-492:53) " self," -(865:52-865:60) " source," --> (492:53-492:61) " source," -(865:60-865:67) " owner," --> (492:61-492:68) " owner," -(865:67-865:73) " props" --> (492:68-492:74) " props" -(865:73-866:1) ");\n" --> (492:74-493:2) ");\n\t" -(866:1-875:0) "}\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param {?object} object\n * @return {boolean} True if `object` is a ReactElement.\n * @final\n */\n" --> (493:2-494:2) "\t}\n\t" -(875:0-875:9) "\nfunction" --> (494:2-494:11) "\tfunction" -(875:9-875:24) " isValidElement" --> (494:11-494:26) " isValidElement" -(875:24-875:32) "(object)" --> (494:26-494:34) "(object)" -(875:32-876:2) " {\n " --> (494:34-495:0) " {" -(876:2-876:16) " return typeof" --> (495:0-495:17) "\n\t\t\treturn typeof" -(876:16-876:27) " object ===" --> (495:17-495:28) " object ===" -(876:27-876:39) " 'object' &&" --> (495:28-495:40) " \"object\" &&" -(876:39-876:50) " object !==" --> (495:40-495:51) " object !==" -(876:50-876:58) " null &&" --> (495:51-495:59) " null &&" -(876:58-876:65) " object" --> (495:59-495:66) " object" -(876:65-876:78) ".$$typeof ===" --> (495:66-495:79) ".$$typeof ===" -(876:78-877:1) " REACT_ELEMENT_TYPE;\n" --> (495:79-496:2) " REACT_ELEMENT_TYPE;\n\t" -(877:1-879:0) "}\n" --> (496:2-497:2) "\t}\n\t" -(879:0-879:4) "\nvar" --> (497:2-497:6) "\tvar" -(879:4-879:16) " SEPARATOR =" --> (497:6-497:18) " SEPARATOR =" -(879:16-880:0) " '.';" --> (497:18-498:2) " \".\";\n\t" -(880:0-880:4) "\nvar" --> (498:2-498:6) "\tvar" -(880:4-880:19) " SUBSEPARATOR =" --> (498:6-498:21) " SUBSEPARATOR =" -(880:19-888:0) " ':';\n/**\n * Escape and wrap key so it is safe to use as a reactid\n *\n * @param {string} key to be escaped.\n * @return {string} the escaped key.\n */\n" --> (498:21-499:2) " \":\";\n\t" -(888:0-888:9) "\nfunction" --> (499:2-499:11) "\tfunction" -(888:9-888:16) " escape" --> (499:11-499:18) " escape" -(888:16-888:21) "(key)" --> (499:18-499:23) "(key)" -(888:21-889:2) " {\n " --> (499:23-500:3) " {\n\t\t" -(889:2-889:6) " var" --> (500:3-500:7) "\tvar" -(889:6-889:20) " escapeRegex =" --> (500:7-500:21) " escapeRegex =" -(889:20-890:2) " /[=:]/g;\n " --> (500:21-501:3) " /[=:]/g;\n\t\t" -(890:2-890:6) " var" --> (501:3-501:7) "\tvar" -(890:6-890:22) " escaperLookup =" --> (501:7-501:23) " escaperLookup =" -(890:22-891:4) " {\n " --> (501:23-502:4) " {\n\t\t\t" -(891:4-891:9) " '=':" --> (502:4-502:9) "\t\"=\":" -(891:9-892:4) " '=0',\n " --> (502:9-503:4) " \"=0\",\n\t\t\t" -(892:4-892:9) " ':':" --> (503:4-503:9) "\t\":\":" -(892:9-893:3) " '=2'\n " --> (503:9-504:3) " \"=2\"\n\t\t" -(893:3-894:2) "};\n " --> (504:3-505:3) "\t};\n\t\t" -(894:2-894:6) " var" --> (505:3-505:7) "\tvar" -(894:6-894:22) " escapedString =" --> (505:7-505:23) " escapedString =" -(894:22-894:26) " key" --> (505:23-505:27) " key" -(894:26-894:34) ".replace" --> (505:27-505:35) ".replace" -(894:34-894:47) "(escapeRegex," --> (505:35-505:48) "(escapeRegex," -(894:47-894:57) " function " --> (505:48-505:57) " function" -(894:57-894:64) "(match)" --> (505:57-505:64) "(match)" -(894:64-895:4) " {\n " --> (505:64-506:0) " {" -(895:4-895:11) " return" --> (506:0-506:11) "\n\t\t\t\treturn" -(895:11-895:25) " escaperLookup" --> (506:11-506:25) " escaperLookup" -(895:25-896:3) "[match];\n " --> (506:25-507:3) "[match];\n\t\t" -(896:3-896:4) "}" --> (507:3-507:5) "\t}" -(896:4-897:2) ");\n " --> (507:5-508:0) ");" -(897:2-897:9) " return" --> (508:0-508:10) "\n\t\t\treturn" -(897:9-897:15) " '$' +" --> (508:10-508:16) " \"$\" +" -(897:15-898:1) " escapedString;\n" --> (508:16-509:2) " escapedString;\n\t" -(898:1-905:0) "}\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\n" --> (509:2-510:2) "\t}\n\t" -(905:0-905:4) "\nvar" --> (510:2-510:6) "\tvar" -(905:4-905:23) " didWarnAboutMaps =" --> (510:6-510:25) " didWarnAboutMaps =" -(905:23-906:0) " false;" --> (510:25-511:2) " false;\n\t" -(906:0-906:4) "\nvar" --> (511:2-511:6) "\tvar" -(906:4-906:33) " userProvidedKeyEscapeRegex =" --> (511:6-511:35) " userProvidedKeyEscapeRegex =" -(906:33-908:0) " /\\/+/g;\n" --> (511:35-512:2) " /\\/+/g;\n\t" -(908:0-908:9) "\nfunction" --> (512:2-512:11) "\tfunction" -(908:9-908:31) " escapeUserProvidedKey" --> (512:11-512:33) " escapeUserProvidedKey" -(908:31-908:37) "(text)" --> (512:33-512:39) "(text)" -(908:37-909:2) " {\n " --> (512:39-513:0) " {" -(909:2-909:9) " return" --> (513:0-513:10) "\n\t\t\treturn" -(909:9-909:14) " text" --> (513:10-513:15) " text" -(909:14-909:22) ".replace" --> (513:15-513:23) ".replace" -(909:22-909:50) "(userProvidedKeyEscapeRegex," --> (513:23-513:51) "(userProvidedKeyEscapeRegex," -(909:50-909:56) " '$&/'" --> (513:51-513:57) " \"$&/\"" -(909:56-910:1) ");\n" --> (513:57-514:2) ");\n\t" -(910:1-920:0) "}\n/**\n * Generate a key string that identifies a element within a set.\n *\n * @param {*} element A element that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\n\n" --> (514:2-515:2) "\t}\n\t" -(920:0-920:9) "\nfunction" --> (515:2-515:11) "\tfunction" -(920:9-920:23) " getElementKey" --> (515:11-515:25) " getElementKey" -(920:23-920:32) "(element," --> (515:25-515:34) "(element," -(920:32-920:39) " index)" --> (515:34-515:41) " index)" -(920:39-923:2) " {\n // Do some typechecking here since we call this blindly. We want to ensure\n // that we don't block potential future ES APIs.\n " --> (515:41-516:0) " {" -(923:2-923:13) " if (typeof" --> (516:0-516:14) "\n\t\t\tif (typeof" -(923:13-923:25) " element ===" --> (516:14-516:26) " element ===" -(923:25-923:37) " 'object' &&" --> (516:26-516:38) " \"object\" &&" -(923:37-923:49) " element !==" --> (516:38-516:50) " element !==" -(923:49-923:57) " null &&" --> (516:50-516:58) " null &&" -(923:57-923:65) " element" --> (516:58-516:66) " element" -(923:65-923:72) ".key !=" --> (516:66-516:73) ".key !=" -(923:72-923:78) " null)" --> (516:73-516:79) " null)" -(923:78-925:4) " {\n // Explicit key\n " --> (516:79-517:0) " {" -(925:4-925:11) " return" --> (517:0-517:11) "\n\t\t\t\treturn" -(925:11-925:18) " escape" --> (517:11-517:18) " escape" -(925:18-925:23) "('' +" --> (517:18-517:23) "(\"\" +" -(925:23-925:31) " element" --> (517:23-517:31) " element" -(925:31-925:35) ".key" --> (517:31-517:35) ".key" -(925:35-926:3) ");\n " --> (517:35-518:3) ");\n\t\t" -(926:3-929:2) "} // Implicit key determined by the index in the set\n\n\n " --> (518:3-519:0) "\t}" -(929:2-929:9) " return" --> (519:0-519:10) "\n\t\t\treturn" -(929:9-929:15) " index" --> (519:10-519:16) " index" -(929:15-929:24) ".toString" --> (519:16-519:25) ".toString" -(929:24-929:27) "(36" --> (519:25-519:28) "(36" -(929:27-930:1) ");\n" --> (519:28-520:2) ");\n\t" -(930:1-932:0) "}\n" --> (520:2-521:2) "\t}\n\t" -(932:0-932:9) "\nfunction" --> (521:2-521:11) "\tfunction" -(932:9-932:22) " mapIntoArray" --> (521:11-521:24) " mapIntoArray" -(932:22-932:32) "(children," --> (521:24-521:34) "(children," -(932:32-932:39) " array," --> (521:34-521:41) " array," -(932:39-932:54) " escapedPrefix," --> (521:41-521:56) " escapedPrefix," -(932:54-932:65) " nameSoFar," --> (521:56-521:67) " nameSoFar," -(932:65-932:75) " callback)" --> (521:67-521:77) " callback)" -(932:75-933:2) " {\n " --> (521:77-522:3) " {\n\t\t" -(933:2-933:6) " var" --> (522:3-522:7) "\tvar" -(933:6-933:20) " type = typeof" --> (522:7-522:21) " type = typeof" -(933:20-935:2) " children;\n\n " --> (522:21-523:0) " children;" -(935:2-935:6) " if " --> (523:0-523:7) "\n\t\t\tif " -(935:6-935:15) "(type ===" --> (523:7-523:16) "(type ===" -(935:15-935:30) " 'undefined' ||" --> (523:16-523:31) " \"undefined\" ||" -(935:30-935:39) " type ===" --> (523:31-523:40) " type ===" -(935:39-935:50) " 'boolean')" --> (523:40-523:51) " \"boolean\")" -(935:50-937:4) " {\n // All of the above are perceived as null.\n " --> (523:51-524:0) " {" -(937:4-937:15) " children =" --> (524:0-524:15) "\n\t\t\t\tchildren =" -(937:15-938:3) " null;\n " --> (524:15-525:3) " null;\n\t\t" -(938:3-940:2) "}\n\n " --> (525:3-526:3) "\t}\n\t\t" -(940:2-940:6) " var" --> (526:3-526:7) "\tvar" -(940:6-940:23) " invokeCallback =" --> (526:7-526:24) " invokeCallback =" -(940:23-942:2) " false;\n\n " --> (526:24-527:0) " false;" -(942:2-942:6) " if " --> (527:0-527:7) "\n\t\t\tif " -(942:6-942:19) "(children ===" --> (527:7-527:20) "(children ===" -(942:19-942:25) " null)" --> (527:20-527:26) " null)" -(942:25-943:4) " {\n " --> (527:26-528:0) " {" -(943:4-943:21) " invokeCallback =" --> (528:0-528:21) "\n\t\t\t\tinvokeCallback =" -(943:21-944:3) " true;\n " --> (528:21-529:3) " true;\n\t\t" -(944:3-944:9) "} else" --> (529:3-529:10) "\t} else" -(944:9-945:4) " {\n " --> (529:10-530:0) " {" -(945:4-945:12) " switch " --> (530:0-530:12) "\n\t\t\t\tswitch " -(945:12-945:4) " switch " --> (530:12-530:18) "(type)" -(945:4-946:6) " switch (type) {\n " --> (530:18-531:0) " {" -(946:6-946:11) " case" --> (531:0-531:10) "\n\t\t\t\t\tcase" -(946:11-947:6) " 'string':\n " --> (531:10-532:0) " \"string\":" -(947:6-947:11) " case" --> (532:0-532:10) "\n\t\t\t\t\tcase" -(947:11-948:8) " 'number':\n " --> (532:10-533:0) " \"number\":" -(948:8-948:25) " invokeCallback =" --> (533:0-533:23) "\n\t\t\t\t\t\tinvokeCallback =" -(948:25-949:8) " true;\n " --> (533:23-534:0) " true;" -(949:8-951:6) " break;\n\n " --> (534:0-535:0) "\n\t\t\t\t\t\tbreak;" -(951:6-951:11) " case" --> (535:0-535:10) "\n\t\t\t\t\tcase" -(951:11-952:8) " 'object':\n " --> (535:10-535:19) " \"object\"" -(952:8-952:16) " switch " --> (535:19-535:28) ": switch " -(952:16-952:25) "(children" --> (535:28-535:37) "(children" -(952:25-952:8) " switch (children" --> (535:37-535:47) ".$$typeof)" -(952:8-953:10) " switch (children.$$typeof) {\n " --> (535:47-536:0) " {" -(953:10-953:15) " case" --> (536:0-536:11) "\n\t\t\t\t\t\tcase" -(953:15-954:10) " REACT_ELEMENT_TYPE:\n " --> (536:11-537:0) " REACT_ELEMENT_TYPE:" -(954:10-954:15) " case" --> (537:0-537:11) "\n\t\t\t\t\t\tcase" -(954:15-955:12) " REACT_PORTAL_TYPE:\n " --> (537:11-537:29) " REACT_PORTAL_TYPE" -(955:12-955:29) " invokeCallback =" --> (537:29-537:47) ": invokeCallback =" -(955:29-956:9) " true;\n " --> (537:47-538:5) " true;\n\t\t\t\t" -(956:9-958:5) "}\n\n " --> (538:5-539:4) "\t}\n\t\t\t" -(958:5-959:3) "}\n " --> (539:4-540:3) "\t}\n\t\t" -(959:3-961:2) "}\n\n " --> (540:3-541:0) "\t}" -(961:2-961:6) " if " --> (541:0-541:7) "\n\t\t\tif " -(961:6-961:22) "(invokeCallback)" --> (541:7-541:23) "(invokeCallback)" -(961:22-962:4) " {\n " --> (541:23-542:4) " {\n\t\t\t" -(962:4-962:8) " var" --> (542:4-542:8) "\tvar" -(962:8-962:17) " _child =" --> (542:8-542:17) " _child =" -(962:17-963:4) " children;\n " --> (542:17-543:4) " children;\n\t\t\t" -(963:4-963:8) " var" --> (543:4-543:8) "\tvar" -(963:8-963:22) " mappedChild =" --> (543:8-543:22) " mappedChild =" -(963:22-963:31) " callback" --> (543:22-543:31) " callback" -(963:31-963:38) "(_child" --> (543:31-543:38) "(_child" -(963:38-966:4) "); // If it's the only child, treat the name as if it was wrapped in an array\n // so that it's consistent if the number of children grows:\n\n " --> (543:38-544:4) ");\n\t\t\t" -(966:4-966:8) " var" --> (544:4-544:8) "\tvar" -(966:8-966:19) " childKey =" --> (544:8-544:19) " childKey =" -(966:19-966:33) " nameSoFar ===" --> (544:19-544:33) " nameSoFar ===" -(966:33-966:38) " '' ?" --> (544:33-544:38) " \"\" ?" -(966:38-966:50) " SEPARATOR +" --> (544:38-544:50) " SEPARATOR +" -(966:50-966:64) " getElementKey" --> (544:50-544:64) " getElementKey" -(966:64-966:72) "(_child," --> (544:64-544:72) "(_child," -(966:72-966:74) " 0" --> (544:72-544:74) " 0" -(966:74-966:77) ") :" --> (544:74-544:77) ") :" -(966:77-968:4) " nameSoFar;\n\n " --> (544:77-545:0) " nameSoFar;" -(968:4-968:8) " if " --> (545:0-545:8) "\n\t\t\t\tif " -(968:8-968:14) "(Array" --> (545:8-545:14) "(Array" -(968:14-968:22) ".isArray" --> (545:14-545:22) ".isArray" -(968:22-968:34) "(mappedChild" --> (545:22-545:34) "(mappedChild" -(968:34-968:36) "))" --> (545:34-545:36) "))" -(968:36-969:6) " {\n " --> (545:36-546:5) " {\n\t\t\t\t" -(969:6-969:10) " var" --> (546:5-546:9) "\tvar" -(969:10-969:28) " escapedChildKey =" --> (546:9-546:27) " escapedChildKey =" -(969:28-971:6) " '';\n\n " --> (546:27-547:0) " \"\";" -(971:6-971:10) " if " --> (547:0-547:9) "\n\t\t\t\t\tif " -(971:10-971:22) "(childKey !=" --> (547:9-547:21) "(childKey !=" -(971:22-971:28) " null)" --> (547:21-547:27) " null)" -(971:28-972:8) " {\n " --> (547:27-548:0) " {" -(972:8-972:26) " escapedChildKey =" --> (548:0-548:24) "\n\t\t\t\t\t\tescapedChildKey =" -(972:26-972:48) " escapeUserProvidedKey" --> (548:24-548:46) " escapeUserProvidedKey" -(972:48-972:57) "(childKey" --> (548:46-548:55) "(childKey" -(972:57-972:60) ") +" --> (548:55-548:58) ") +" -(972:60-973:7) " '/';\n " --> (548:58-549:5) " \"/\";\n\t\t\t\t" -(973:7-975:6) "}\n\n " --> (549:5-550:0) "\t}" -(975:6-975:19) " mapIntoArray" --> (550:0-550:18) "\n\t\t\t\t\tmapIntoArray" -(975:19-975:32) "(mappedChild," --> (550:18-550:31) "(mappedChild," -(975:32-975:39) " array," --> (550:31-550:38) " array," -(975:39-975:56) " escapedChildKey," --> (550:38-550:55) " escapedChildKey," -(975:56-975:60) " ''," --> (550:55-550:59) " \"\"," -(975:60-975:70) " function " --> (550:59-550:68) " function" -(975:70-975:73) "(c)" --> (550:68-550:71) "(c)" -(975:73-976:8) " {\n " --> (550:71-551:0) " {" -(976:8-976:15) " return" --> (551:0-551:13) "\n\t\t\t\t\t\treturn" -(976:15-977:7) " c;\n " --> (551:13-552:5) " c;\n\t\t\t\t" -(977:7-977:8) "}" --> (552:5-552:7) "\t}" -(977:8-978:5) ");\n " --> (552:7-553:4) ");\n\t\t\t" -(978:5-978:15) "} else if " --> (553:4-553:15) "\t} else if " -(978:15-978:30) "(mappedChild !=" --> (553:15-553:30) "(mappedChild !=" -(978:30-978:36) " null)" --> (553:30-553:36) " null)" -(978:36-979:6) " {\n " --> (553:36-554:0) " {" -(979:6-979:10) " if " --> (554:0-554:9) "\n\t\t\t\t\tif " -(979:10-979:25) "(isValidElement" --> (554:9-554:24) "(isValidElement" -(979:25-979:37) "(mappedChild" --> (554:24-554:36) "(mappedChild" -(979:37-979:39) "))" --> (554:36-554:38) "))" -(979:39-980:8) " {\n " --> (554:38-555:0) " {" -(980:8-980:22) " mappedChild =" --> (555:0-555:20) "\n\t\t\t\t\t\tmappedChild =" -(980:22-980:41) " cloneAndReplaceKey" --> (555:20-555:39) " cloneAndReplaceKey" -(980:41-982:8) "(mappedChild, // Keep both the (mapped) and old keys if they differ, just as\n // traverseAllChildren used to do for objects as children\n " --> (555:39-555:52) "(mappedChild," -(982:8-983:8) " escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key\n " --> (555:52-555:69) " escapedPrefix + " -(983:8-983:20) " mappedChild" --> (555:69-555:81) "(mappedChild" -(983:20-983:29) ".key && (" --> (555:81-555:90) ".key && (" -(983:29-983:39) "!_child ||" --> (555:90-555:100) "!_child ||" -(983:39-983:46) " _child" --> (555:100-555:107) " _child" -(983:46-983:54) ".key !==" --> (555:107-555:115) ".key !==" -(983:54-983:66) " mappedChild" --> (555:115-555:127) " mappedChild" -(983:66-984:8) ".key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number\n " --> (555:127-555:134) ".key) ?" -(984:8-984:30) " escapeUserProvidedKey" --> (555:134-555:156) " escapeUserProvidedKey" -(984:30-984:35) "('' +" --> (555:156-555:161) "(\"\" +" -(984:35-984:47) " mappedChild" --> (555:161-555:173) " mappedChild" -(984:47-984:51) ".key" --> (555:173-555:177) ".key" -(984:51-984:54) ") +" --> (555:177-555:180) ") +" -(984:54-984:60) " '/' :" --> (555:180-555:186) " \"/\" :" -(984:60-984:66) " '') +" --> (555:186-555:192) " \"\") +" -(984:66-984:75) " childKey" --> (555:192-555:201) " childKey" -(984:75-985:7) ");\n " --> (555:201-556:5) ");\n\t\t\t\t" -(985:7-987:6) "}\n\n " --> (556:5-557:0) "\t}" -(987:6-987:12) " array" --> (557:0-557:11) "\n\t\t\t\t\tarray" -(987:12-987:17) ".push" --> (557:11-557:16) ".push" -(987:17-987:29) "(mappedChild" --> (557:16-557:28) "(mappedChild" -(987:29-988:5) ");\n " --> (557:28-558:4) ");\n\t\t\t" -(988:5-990:4) "}\n\n " --> (558:4-559:0) "\t}" -(990:4-990:11) " return" --> (559:0-559:11) "\n\t\t\t\treturn" -(990:11-991:3) " 1;\n " --> (559:11-560:3) " 1;\n\t\t" -(991:3-993:2) "}\n\n " --> (560:3-561:3) "\t}\n\t\t" -(993:2-993:6) " var" --> (561:3-561:7) "\tvar" -(993:6-994:2) " child;\n " --> (561:7-562:3) " child;\n\t\t" -(994:2-994:6) " var" --> (562:3-562:7) "\tvar" -(994:6-995:2) " nextName;\n " --> (562:7-563:3) " nextName;\n\t\t" -(995:2-995:6) " var" --> (563:3-563:7) "\tvar" -(995:6-995:21) " subtreeCount =" --> (563:7-563:22) " subtreeCount =" -(995:21-997:2) " 0; // Count of children found in the current subtree.\n\n " --> (563:22-564:3) " 0;\n\t\t" -(997:2-997:6) " var" --> (564:3-564:7) "\tvar" -(997:6-997:23) " nextNamePrefix =" --> (564:7-564:24) " nextNamePrefix =" -(997:23-997:37) " nameSoFar ===" --> (564:24-564:38) " nameSoFar ===" -(997:37-997:42) " '' ?" --> (564:38-564:43) " \"\" ?" -(997:42-997:54) " SEPARATOR :" --> (564:43-564:55) " SEPARATOR :" -(997:54-997:66) " nameSoFar +" --> (564:55-564:67) " nameSoFar +" -(997:66-999:2) " SUBSEPARATOR;\n\n " --> (564:67-565:0) " SUBSEPARATOR;" -(999:2-999:6) " if " --> (565:0-565:7) "\n\t\t\tif " -(999:6-999:12) "(Array" --> (565:7-565:13) "(Array" -(999:12-999:20) ".isArray" --> (565:13-565:21) ".isArray" -(999:20-999:29) "(children" --> (565:21-565:30) "(children" -(999:29-999:31) "))" --> (565:30-565:32) "))" -(999:31-1000:4) " {\n " --> (565:32-566:0) " {" -(1000:4-1000:9) " for " --> (566:0-566:9) "\n\t\t\t\tfor " -(1000:9-1000:13) "(var" --> (566:9-566:13) "(var" -(1000:13-1000:17) " i =" --> (566:13-566:17) " i =" -(1000:17-1000:20) " 0;" --> (566:17-566:20) " 0;" -(1000:20-1000:24) " i <" --> (566:20-566:24) " i <" -(1000:24-1000:33) " children" --> (566:24-566:33) " children" -(1000:33-1000:41) ".length;" --> (566:33-566:41) ".length;" -(1000:41-1000:46) " i++)" --> (566:41-566:46) " i++)" -(1000:46-1001:6) " {\n " --> (566:46-567:0) " {" -(1001:6-1001:14) " child =" --> (567:0-567:13) "\n\t\t\t\t\tchild =" -(1001:14-1001:23) " children" --> (567:13-567:22) " children" -(1001:23-1002:6) "[i];\n " --> (567:22-568:0) "[i];" -(1002:6-1002:17) " nextName =" --> (568:0-568:16) "\n\t\t\t\t\tnextName =" -(1002:17-1002:34) " nextNamePrefix +" --> (568:16-568:33) " nextNamePrefix +" -(1002:34-1002:48) " getElementKey" --> (568:33-568:47) " getElementKey" -(1002:48-1002:55) "(child," --> (568:47-568:54) "(child," -(1002:55-1002:57) " i" --> (568:54-568:56) " i" -(1002:57-1003:6) ");\n " --> (568:56-569:0) ");" -(1003:6-1003:22) " subtreeCount +=" --> (569:0-569:21) "\n\t\t\t\t\tsubtreeCount +=" -(1003:22-1003:35) " mapIntoArray" --> (569:21-569:34) " mapIntoArray" -(1003:35-1003:42) "(child," --> (569:34-569:41) "(child," -(1003:42-1003:49) " array," --> (569:41-569:48) " array," -(1003:49-1003:64) " escapedPrefix," --> (569:48-569:63) " escapedPrefix," -(1003:64-1003:74) " nextName," --> (569:63-569:73) " nextName," -(1003:74-1003:83) " callback" --> (569:73-569:82) " callback" -(1003:83-1004:5) ");\n " --> (569:82-570:4) ");\n\t\t\t" -(1004:5-1005:3) "}\n " --> (570:4-571:3) "\t}\n\t\t" -(1005:3-1005:9) "} else" --> (571:3-571:10) "\t} else" -(1005:9-1006:4) " {\n " --> (571:10-572:4) " {\n\t\t\t" -(1006:4-1006:8) " var" --> (572:4-572:8) "\tvar" -(1006:8-1006:21) " iteratorFn =" --> (572:8-572:21) " iteratorFn =" -(1006:21-1006:35) " getIteratorFn" --> (572:21-572:35) " getIteratorFn" -(1006:35-1006:44) "(children" --> (572:35-572:44) "(children" -(1006:44-1008:4) ");\n\n " --> (572:44-573:0) ");" -(1008:4-1008:15) " if (typeof" --> (573:0-573:15) "\n\t\t\t\tif (typeof" -(1008:15-1008:30) " iteratorFn ===" --> (573:15-573:30) " iteratorFn ===" -(1008:30-1008:42) " 'function')" --> (573:30-573:42) " \"function\")" -(1008:42-1009:6) " {\n " --> (573:42-574:5) " {\n\t\t\t\t" -(1009:6-1009:10) " var" --> (574:5-574:9) "\tvar" -(1009:10-1009:29) " iterableChildren =" --> (574:9-574:28) " iterableChildren =" -(1009:29-1011:6) " children;\n\n " --> (574:28-575:5) " children;\n\t\t\t\t" -(1011:6-1013:8) " {\n // Warn about using Maps as children\n " --> (575:5-576:0) "\t{" -(1013:8-1013:12) " if " --> (576:0-576:10) "\n\t\t\t\t\t\tif " -(1013:12-1013:27) "(iteratorFn ===" --> (576:10-576:25) "(iteratorFn ===" -(1013:27-1013:44) " iterableChildren" --> (576:25-576:42) " iterableChildren" -(1013:44-1013:53) ".entries)" --> (576:42-576:51) ".entries)" -(1013:53-1014:10) " {\n " --> (576:51-577:0) " {" -(1014:10-1014:15) " if (" --> (577:0-577:12) "\n\t\t\t\t\t\t\tif (" -(1014:15-1014:33) "!didWarnAboutMaps)" --> (577:12-577:30) "!didWarnAboutMaps)" -(1014:33-1015:12) " {\n " --> (577:30-578:0) " {" -(1015:12-1015:17) " warn" --> (578:0-578:13) "\n\t\t\t\t\t\t\t\twarn" -(1015:17-1015:63) "('Using Maps as children is not supported. ' +" --> (578:13-578:59) "(\"Using Maps as children is not supported. \" +" -(1015:63-1015:110) " 'Use an array of keyed ReactElements instead.'" --> (578:59-578:106) " \"Use an array of keyed ReactElements instead.\"" -(1015:110-1016:11) ");\n " --> (578:106-579:7) ");\n\t\t\t\t\t\t" -(1016:11-1018:10) "}\n\n " --> (579:7-580:0) "\t}" -(1018:10-1018:29) " didWarnAboutMaps =" --> (580:0-580:26) "\n\t\t\t\t\t\t\tdidWarnAboutMaps =" -(1018:29-1019:9) " true;\n " --> (580:26-581:6) " true;\n\t\t\t\t\t" -(1019:9-1020:7) "}\n " --> (581:6-582:5) "\t}\n\t\t\t\t" -(1020:7-1022:6) "}\n\n " --> (582:5-583:5) "\t}\n\t\t\t\t" -(1022:6-1022:10) " var" --> (583:5-583:9) "\tvar" -(1022:10-1022:21) " iterator =" --> (583:9-583:20) " iterator =" -(1022:21-1022:32) " iteratorFn" --> (583:20-583:31) " iteratorFn" -(1022:32-1022:37) ".call" --> (583:31-583:36) ".call" -(1022:37-1022:54) "(iterableChildren" --> (583:36-583:53) "(iterableChildren" -(1022:54-1023:6) ");\n " --> (583:53-584:5) ");\n\t\t\t\t" -(1023:6-1023:10) " var" --> (584:5-584:9) "\tvar" -(1023:10-1024:6) " step;\n " --> (584:9-585:5) " step;\n\t\t\t\t" -(1024:6-1024:10) " var" --> (585:5-585:9) "\tvar" -(1024:10-1024:15) " ii =" --> (585:9-585:14) " ii =" -(1024:15-1026:6) " 0;\n\n " --> (585:14-586:0) " 0;" -(1026:6-1026:15) " while (!" --> (586:0-586:14) "\n\t\t\t\t\twhile (!" -(1026:15-1026:22) "(step =" --> (586:14-586:21) "(step =" -(1026:22-1026:31) " iterator" --> (586:21-586:30) " iterator" -(1026:31-1026:37) ".next(" --> (586:30-586:36) ".next(" -(1026:37-1026:39) "))" --> (586:36-586:38) "))" -(1026:39-1026:45) ".done)" --> (586:38-586:44) ".done)" -(1026:45-1027:8) " {\n " --> (586:44-587:0) " {" -(1027:8-1027:16) " child =" --> (587:0-587:14) "\n\t\t\t\t\t\tchild =" -(1027:16-1027:21) " step" --> (587:14-587:19) " step" -(1027:21-1028:8) ".value;\n " --> (587:19-588:0) ".value;" -(1028:8-1028:19) " nextName =" --> (588:0-588:17) "\n\t\t\t\t\t\tnextName =" -(1028:19-1028:36) " nextNamePrefix +" --> (588:17-588:34) " nextNamePrefix +" -(1028:36-1028:50) " getElementKey" --> (588:34-588:48) " getElementKey" -(1028:50-1028:57) "(child," --> (588:48-588:55) "(child," -(1028:57-1028:62) " ii++" --> (588:55-588:60) " ii++" -(1028:62-1029:8) ");\n " --> (588:60-589:0) ");" -(1029:8-1029:24) " subtreeCount +=" --> (589:0-589:22) "\n\t\t\t\t\t\tsubtreeCount +=" -(1029:24-1029:37) " mapIntoArray" --> (589:22-589:35) " mapIntoArray" -(1029:37-1029:44) "(child," --> (589:35-589:42) "(child," -(1029:44-1029:51) " array," --> (589:42-589:49) " array," -(1029:51-1029:66) " escapedPrefix," --> (589:49-589:64) " escapedPrefix," -(1029:66-1029:76) " nextName," --> (589:64-589:74) " nextName," -(1029:76-1029:85) " callback" --> (589:74-589:83) " callback" -(1029:85-1030:7) ");\n " --> (589:83-590:5) ");\n\t\t\t\t" -(1030:7-1031:5) "}\n " --> (590:5-591:4) "\t}\n\t\t\t" -(1031:5-1031:15) "} else if " --> (591:4-591:15) "\t} else if " -(1031:15-1031:24) "(type ===" --> (591:15-591:24) "(type ===" -(1031:24-1031:34) " 'object')" --> (591:24-591:34) " \"object\")" -(1031:34-1032:6) " {\n " --> (591:34-592:5) " {\n\t\t\t\t" -(1032:6-1032:10) " var" --> (592:5-592:9) "\tvar" -(1032:10-1032:27) " childrenString =" --> (592:9-592:26) " childrenString =" -(1032:27-1032:32) " '' +" --> (592:26-592:31) " \"\" +" -(1032:32-1034:6) " children;\n\n " --> (592:31-593:5) " children;\n\t\t\t\t" -(1034:6-1035:8) " {\n " --> (593:5-594:6) "\t{\n\t\t\t\t\t" -(1035:8-1036:10) " {\n " --> (594:6-595:0) "\t{" -(1036:10-1036:16) " throw" --> (595:0-595:13) "\n\t\t\t\t\t\t\tthrow" -(1036:16-1036:23) " Error(" --> (595:13-595:19) " Error" -(1036:23-1036:76) " \"Objects are not valid as a React child (found: \" + " --> (595:19-595:72) "(\"Objects are not valid as a React child (found: \" + " -(1036:76-1036:95) "(childrenString ===" --> (595:72-595:91) "(childrenString ===" -(1036:95-1036:115) " '[object Object]' ?" --> (595:91-595:111) " \"[object Object]\" ?" -(1036:115-1036:138) " 'object with keys {' +" --> (595:111-595:134) " \"object with keys {\" +" -(1036:138-1036:145) " Object" --> (595:134-595:141) " Object" -(1036:145-1036:150) ".keys" --> (595:141-595:146) ".keys" -(1036:150-1036:159) "(children" --> (595:146-595:155) "(children" -(1036:159-1036:160) ")" --> (595:155-595:156) ")" -(1036:160-1036:165) ".join" --> (595:156-595:161) ".join" -(1036:165-1036:170) "(', '" --> (595:161-595:166) "(\", \"" -(1036:170-1036:173) ") +" --> (595:166-595:169) ") +" -(1036:173-1036:179) " '}' :" --> (595:169-595:175) " \"}\" :" -(1036:179-1036:197) " childrenString) +" --> (595:175-595:193) " childrenString) +" -(1036:197-1036:274) " \"). If you meant to render a collection of children, use an array instead.\" " --> (595:193-595:269) " \"). If you meant to render a collection of children, use an array instead.\"" -(1036:274-1037:9) ");\n " --> (595:269-596:6) ");\n\t\t\t\t\t" -(1037:9-1038:7) "}\n " --> (596:6-597:5) "\t}\n\t\t\t\t" -(1038:7-1039:5) "}\n " --> (597:5-598:4) "\t}\n\t\t\t" -(1039:5-1040:3) "}\n " --> (598:4-599:3) "\t}\n\t\t" -(1040:3-1042:2) "}\n\n " --> (599:3-600:0) "\t}" -(1042:2-1042:9) " return" --> (600:0-600:10) "\n\t\t\treturn" -(1042:9-1043:1) " subtreeCount;\n" --> (600:10-601:2) " subtreeCount;\n\t" -(1043:1-1058:0) "}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\n *\n * The provided mapFunction(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} func The map function.\n * @param {*} context Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */" --> (601:2-602:2) "\t}\n\t" -(1058:0-1058:9) "\nfunction" --> (602:2-602:11) "\tfunction" -(1058:9-1058:21) " mapChildren" --> (602:11-602:23) " mapChildren" -(1058:21-1058:31) "(children," --> (602:23-602:33) "(children," -(1058:31-1058:37) " func," --> (602:33-602:39) " func," -(1058:37-1058:46) " context)" --> (602:39-602:48) " context)" -(1058:46-1059:2) " {\n " --> (602:48-603:0) " {" -(1059:2-1059:6) " if " --> (603:0-603:7) "\n\t\t\tif " -(1059:6-1059:18) "(children ==" --> (603:7-603:19) "(children ==" -(1059:18-1059:24) " null)" --> (603:19-603:25) " null)" -(1059:24-1060:4) " {\n " --> (603:25-604:0) " {" -(1060:4-1060:11) " return" --> (604:0-604:11) "\n\t\t\t\treturn" -(1060:11-1061:3) " children;\n " --> (604:11-605:3) " children;\n\t\t" -(1061:3-1063:2) "}\n\n " --> (605:3-606:3) "\t}\n\t\t" -(1063:2-1063:6) " var" --> (606:3-606:7) "\tvar" -(1063:6-1063:15) " result =" --> (606:7-606:16) " result =" -(1063:15-1063:17) " [" --> (606:16-606:18) " [" -(1063:17-1064:2) "];\n " --> (606:18-607:3) "];\n\t\t" -(1064:2-1064:6) " var" --> (607:3-607:7) "\tvar" -(1064:6-1064:14) " count =" --> (607:7-607:15) " count =" -(1064:14-1065:2) " 0;\n " --> (607:15-608:0) " 0;" -(1065:2-1065:15) " mapIntoArray" --> (608:0-608:16) "\n\t\t\tmapIntoArray" -(1065:15-1065:25) "(children," --> (608:16-608:26) "(children," -(1065:25-1065:33) " result," --> (608:26-608:34) " result," -(1065:33-1065:37) " ''," --> (608:34-608:38) " \"\"," -(1065:37-1065:41) " ''," --> (608:38-608:42) " \"\"," -(1065:41-1065:51) " function " --> (608:42-608:51) " function" -(1065:51-1065:58) "(child)" --> (608:51-608:58) "(child)" -(1065:58-1066:4) " {\n " --> (608:58-609:0) " {" -(1066:4-1066:11) " return" --> (609:0-609:11) "\n\t\t\t\treturn" -(1066:11-1066:16) " func" --> (609:11-609:16) " func" -(1066:16-1066:21) ".call" --> (609:16-609:21) ".call" -(1066:21-1066:30) "(context," --> (609:21-609:30) "(context," -(1066:30-1066:37) " child," --> (609:30-609:37) " child," -(1066:37-1066:45) " count++" --> (609:37-609:45) " count++" -(1066:45-1067:3) ");\n " --> (609:45-610:3) ");\n\t\t" -(1067:3-1067:4) "}" --> (610:3-610:5) "\t}" -(1067:4-1068:2) ");\n " --> (610:5-611:0) ");" -(1068:2-1068:9) " return" --> (611:0-611:10) "\n\t\t\treturn" -(1068:9-1069:1) " result;\n" --> (611:10-612:2) " result;\n\t" -(1069:1-1081:0) "}\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\n\n" --> (612:2-613:2) "\t}\n\t" -(1081:0-1081:9) "\nfunction" --> (613:2-613:11) "\tfunction" -(1081:9-1081:23) " countChildren" --> (613:11-613:25) " countChildren" -(1081:23-1081:33) "(children)" --> (613:25-613:35) "(children)" -(1081:33-1082:2) " {\n " --> (613:35-614:3) " {\n\t\t" -(1082:2-1082:6) " var" --> (614:3-614:7) "\tvar" -(1082:6-1082:10) " n =" --> (614:7-614:11) " n =" -(1082:10-1083:2) " 0;\n " --> (614:11-615:0) " 0;" -(1083:2-1083:14) " mapChildren" --> (615:0-615:15) "\n\t\t\tmapChildren" -(1083:14-1083:24) "(children," --> (615:15-615:25) "(children," -(1083:24-1083:36) " function ()" --> (615:25-615:36) " function()" -(1083:36-1084:4) " {\n " --> (615:36-616:0) " {" -(1084:4-1085:3) " n++; // Don't return anything\n " --> (616:0-617:3) "\n\t\t\t\tn++;\n\t\t" -(1085:3-1085:4) "}" --> (617:3-617:5) "\t}" -(1085:4-1086:2) ");\n " --> (617:5-618:0) ");" -(1086:2-1086:9) " return" --> (618:0-618:10) "\n\t\t\treturn" -(1086:9-1087:1) " n;\n" --> (618:10-619:2) " n;\n\t" -(1087:1-1101:0) "}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc\n * @param {*} forEachContext Context for forEachContext.\n */" --> (619:2-620:2) "\t}\n\t" -(1101:0-1101:9) "\nfunction" --> (620:2-620:11) "\tfunction" -(1101:9-1101:25) " forEachChildren" --> (620:11-620:27) " forEachChildren" -(1101:25-1101:35) "(children," --> (620:27-620:37) "(children," -(1101:35-1101:48) " forEachFunc," --> (620:37-620:50) " forEachFunc," -(1101:48-1101:64) " forEachContext)" --> (620:50-620:66) " forEachContext)" -(1101:64-1102:2) " {\n " --> (620:66-621:0) " {" -(1102:2-1102:14) " mapChildren" --> (621:0-621:15) "\n\t\t\tmapChildren" -(1102:14-1102:24) "(children," --> (621:15-621:25) "(children," -(1102:24-1102:36) " function ()" --> (621:25-621:36) " function()" -(1102:36-1103:4) " {\n " --> (621:36-622:0) " {" -(1103:4-1103:16) " forEachFunc" --> (622:0-622:16) "\n\t\t\t\tforEachFunc" -(1103:16-1103:22) ".apply" --> (622:16-622:22) ".apply" -(1103:22-1103:28) "(this," --> (622:22-622:28) "(this," -(1103:28-1103:38) " arguments" --> (622:28-622:38) " arguments" -(1103:38-1104:3) "); // Don't return anything.\n " --> (622:38-623:3) ");\n\t\t" -(1104:3-1104:5) "}," --> (623:3-623:6) "\t}," -(1104:5-1104:20) " forEachContext" --> (623:6-623:21) " forEachContext" -(1104:20-1105:1) ");\n" --> (623:21-624:2) ");\n\t" -(1105:1-1114:0) "}\n/**\n * Flatten a children object (typically specified as `props.children`) and\n * return an array with appropriately re-keyed children.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\n */\n\n" --> (624:2-625:2) "\t}\n\t" -(1114:0-1114:9) "\nfunction" --> (625:2-625:11) "\tfunction" -(1114:9-1114:17) " toArray" --> (625:11-625:19) " toArray" -(1114:17-1114:27) "(children)" --> (625:19-625:29) "(children)" -(1114:27-1115:2) " {\n " --> (625:29-626:0) " {" -(1115:2-1115:9) " return" --> (626:0-626:10) "\n\t\t\treturn" -(1115:9-1115:21) " mapChildren" --> (626:10-626:22) " mapChildren" -(1115:21-1115:31) "(children," --> (626:22-626:32) "(children," -(1115:31-1115:41) " function " --> (626:32-626:41) " function" -(1115:41-1115:48) "(child)" --> (626:41-626:48) "(child)" -(1115:48-1116:4) " {\n " --> (626:48-627:0) " {" -(1116:4-1116:11) " return" --> (627:0-627:11) "\n\t\t\t\treturn" -(1116:11-1117:3) " child;\n " --> (627:11-628:3) " child;\n\t\t" -(1117:3-1117:4) "}" --> (628:3-628:5) "\t}" -(1117:4-1117:8) ") ||" --> (628:5-628:9) ") ||" -(1117:8-1117:10) " [" --> (628:9-628:11) " [" -(1117:10-1118:1) "];\n" --> (628:11-629:2) "];\n\t" -(1118:1-1135:0) "}\n/**\n * Returns the first child in a collection of children and verifies that there\n * is only one child in the collection.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\n *\n * The current implementation of this function assumes that a single child gets\n * passed without a wrapper, but the purpose of this helper function is to\n * abstract away the particular structure of children.\n *\n * @param {?object} children Child collection structure.\n * @return {ReactElement} The first and only `ReactElement` contained in the\n * structure.\n */\n\n" --> (629:2-630:2) "\t}\n\t" -(1135:0-1135:9) "\nfunction" --> (630:2-630:11) "\tfunction" -(1135:9-1135:19) " onlyChild" --> (630:11-630:21) " onlyChild" -(1135:19-1135:29) "(children)" --> (630:21-630:31) "(children)" -(1135:29-1136:2) " {\n " --> (630:31-631:0) " {" -(1136:2-1136:7) " if (" --> (631:0-631:8) "\n\t\t\tif (" -(1136:7-1136:22) "!isValidElement" --> (631:8-631:23) "!isValidElement" -(1136:22-1136:31) "(children" --> (631:23-631:32) "(children" -(1136:31-1136:33) "))" --> (631:32-631:34) "))" -(1136:33-1137:4) " {\n " --> (631:34-632:4) " {\n\t\t\t" -(1137:4-1138:6) " {\n " --> (632:4-633:0) "\t{" -(1138:6-1138:12) " throw" --> (633:0-633:11) "\n\t\t\t\t\tthrow" -(1138:12-1138:19) " Error(" --> (633:11-633:17) " Error" -(1138:19-1138:92) " \"React.Children.only expected to receive a single React element child.\" " --> (633:17-633:89) "(\"React.Children.only expected to receive a single React element child.\"" -(1138:92-1139:5) ");\n " --> (633:89-634:4) ");\n\t\t\t" -(1139:5-1140:3) "}\n " --> (634:4-635:3) "\t}\n\t\t" -(1140:3-1142:2) "}\n\n " --> (635:3-636:0) "\t}" -(1142:2-1142:9) " return" --> (636:0-636:10) "\n\t\t\treturn" -(1142:9-1143:1) " children;\n" --> (636:10-637:2) " children;\n\t" -(1143:1-1145:0) "}\n" --> (637:2-638:2) "\t}\n\t" -(1145:0-1145:9) "\nfunction" --> (638:2-638:11) "\tfunction" -(1145:9-1145:23) " createContext" --> (638:11-638:25) " createContext" -(1145:23-1145:37) "(defaultValue," --> (638:25-638:39) "(defaultValue," -(1145:37-1145:59) " calculateChangedBits)" --> (638:39-638:61) " calculateChangedBits)" -(1145:59-1146:2) " {\n " --> (638:61-639:0) " {" -(1146:2-1146:6) " if " --> (639:0-639:7) "\n\t\t\tif " -(1146:6-1146:31) "(calculateChangedBits ===" --> (639:7-639:32) "(calculateChangedBits ===" -(1146:31-1146:42) " undefined)" --> (639:32-639:43) " undefined)" -(1146:42-1147:4) " {\n " --> (639:43-640:0) " {" -(1147:4-1147:27) " calculateChangedBits =" --> (640:0-640:27) "\n\t\t\t\tcalculateChangedBits =" -(1147:27-1148:3) " null;\n " --> (640:27-641:3) " null;\n\t\t" -(1148:3-1148:9) "} else" --> (641:3-641:10) "\t} else" -(1148:9-1149:4) " {\n " --> (641:10-642:4) " {\n\t\t\t" -(1149:4-1150:6) " {\n " --> (642:4-643:0) "\t{" -(1150:6-1150:10) " if " --> (643:0-643:9) "\n\t\t\t\t\tif " -(1150:10-1150:35) "(calculateChangedBits !==" --> (643:9-643:34) "(calculateChangedBits !==" -(1150:35-1150:50) " null && typeof" --> (643:34-643:49) " null && typeof" -(1150:50-1150:75) " calculateChangedBits !==" --> (643:49-643:74) " calculateChangedBits !==" -(1150:75-1150:87) " 'function')" --> (643:74-643:86) " \"function\")" -(1150:87-1151:8) " {\n " --> (643:86-644:0) " {" -(1151:8-1151:14) " error" --> (644:0-644:12) "\n\t\t\t\t\t\terror" -(1151:14-1151:80) "('createContext: Expected the optional second argument to be a ' +" --> (644:12-644:78) "(\"createContext: Expected the optional second argument to be a \" +" -(1151:80-1151:114) " 'function. Instead received: %s'," --> (644:78-644:112) " \"function. Instead received: %s\"," -(1151:114-1151:135) " calculateChangedBits" --> (644:112-644:133) " calculateChangedBits" -(1151:135-1152:7) ");\n " --> (644:133-645:5) ");\n\t\t\t\t" -(1152:7-1153:5) "}\n " --> (645:5-646:4) "\t}\n\t\t\t" -(1153:5-1154:3) "}\n " --> (646:4-647:3) "\t}\n\t\t" -(1154:3-1156:2) "}\n\n " --> (647:3-648:3) "\t}\n\t\t" -(1156:2-1156:6) " var" --> (648:3-648:7) "\tvar" -(1156:6-1156:16) " context =" --> (648:7-648:17) " context =" -(1156:16-1157:4) " {\n " --> (648:17-649:4) " {\n\t\t\t" -(1157:4-1157:14) " $$typeof:" --> (649:4-649:14) "\t$$typeof:" -(1157:14-1158:4) " REACT_CONTEXT_TYPE,\n " --> (649:14-650:4) " REACT_CONTEXT_TYPE,\n\t\t\t" -(1158:4-1158:27) " _calculateChangedBits:" --> (650:4-650:27) "\t_calculateChangedBits:" -(1158:27-1164:4) " calculateChangedBits,\n // As a workaround to support multiple concurrent renderers, we categorize\n // some renderers as primary and others as secondary. We only expect\n // there to be two concurrent renderers at most: React Native (primary) and\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\n // Secondary renderers store their context values on separate fields.\n " --> (650:27-651:4) " calculateChangedBits,\n\t\t\t" -(1164:4-1164:19) " _currentValue:" --> (651:4-651:19) "\t_currentValue:" -(1164:19-1165:4) " defaultValue,\n " --> (651:19-652:4) " defaultValue,\n\t\t\t" -(1165:4-1165:20) " _currentValue2:" --> (652:4-652:20) "\t_currentValue2:" -(1165:20-1168:4) " defaultValue,\n // Used to track how many concurrent renderers this context currently\n // supports within in a single renderer. Such as parallel server rendering.\n " --> (652:20-653:4) " defaultValue,\n\t\t\t" -(1168:4-1168:18) " _threadCount:" --> (653:4-653:18) "\t_threadCount:" -(1168:18-1170:4) " 0,\n // These are circular\n " --> (653:18-654:4) " 0,\n\t\t\t" -(1170:4-1170:14) " Provider:" --> (654:4-654:14) "\tProvider:" -(1170:14-1171:4) " null,\n " --> (654:14-655:4) " null,\n\t\t\t" -(1171:4-1171:14) " Consumer:" --> (655:4-655:14) "\tConsumer:" -(1171:14-1172:3) " null\n " --> (655:14-656:3) " null\n\t\t" -(1172:3-1173:2) "};\n " --> (656:3-657:0) "\t};" -(1173:2-1173:10) " context" --> (657:0-657:11) "\n\t\t\tcontext" -(1173:10-1173:21) ".Provider =" --> (657:11-657:22) ".Provider =" -(1173:21-1174:4) " {\n " --> (657:22-658:4) " {\n\t\t\t" -(1174:4-1174:14) " $$typeof:" --> (658:4-658:14) "\t$$typeof:" -(1174:14-1175:4) " REACT_PROVIDER_TYPE,\n " --> (658:14-659:4) " REACT_PROVIDER_TYPE,\n\t\t\t" -(1175:4-1175:14) " _context:" --> (659:4-659:14) "\t_context:" -(1175:14-1176:3) " context\n " --> (659:14-660:3) " context\n\t\t" -(1176:3-1177:2) "};\n " --> (660:3-661:3) "\t};\n\t\t" -(1177:2-1177:6) " var" --> (661:3-661:7) "\tvar" -(1177:6-1177:50) " hasWarnedAboutUsingNestedContextConsumers =" --> (661:7-661:51) " hasWarnedAboutUsingNestedContextConsumers =" -(1177:50-1178:2) " false;\n " --> (661:51-662:3) " false;\n\t\t" -(1178:2-1178:6) " var" --> (662:3-662:7) "\tvar" -(1178:6-1178:44) " hasWarnedAboutUsingConsumerProvider =" --> (662:7-662:45) " hasWarnedAboutUsingConsumerProvider =" -(1178:44-1179:2) " false;\n " --> (662:45-663:3) " false;\n\t\t" -(1179:2-1179:6) " var" --> (663:3-663:7) "\tvar" -(1179:6-1179:44) " hasWarnedAboutDisplayNameOnConsumer =" --> (663:7-663:45) " hasWarnedAboutDisplayNameOnConsumer =" -(1179:44-1181:2) " false;\n\n " --> (663:45-664:3) " false;\n\t\t" -(1181:2-1185:4) " {\n // A separate object, but proxies back to the original context object for\n // backwards compatibility. It has a different $$typeof, so we can properly\n // warn for the incorrect usage of Context as a Consumer.\n " --> (664:3-665:4) "\t{\n\t\t\t" -(1185:4-1185:8) " var" --> (665:4-665:8) "\tvar" -(1185:8-1185:19) " Consumer =" --> (665:8-665:19) " Consumer =" -(1185:19-1186:6) " {\n " --> (665:19-666:5) " {\n\t\t\t\t" -(1186:6-1186:16) " $$typeof:" --> (666:5-666:15) "\t$$typeof:" -(1186:16-1187:6) " REACT_CONTEXT_TYPE,\n " --> (666:15-667:5) " REACT_CONTEXT_TYPE,\n\t\t\t\t" -(1187:6-1187:16) " _context:" --> (667:5-667:15) "\t_context:" -(1187:16-1188:6) " context,\n " --> (667:15-668:5) " context,\n\t\t\t\t" -(1188:6-1188:29) " _calculateChangedBits:" --> (668:5-668:28) "\t_calculateChangedBits:" -(1188:29-1188:37) " context" --> (668:28-668:36) " context" -(1188:37-1189:5) "._calculateChangedBits\n " --> (668:36-669:4) "._calculateChangedBits\n\t\t\t" -(1189:5-1191:4) "}; // $FlowFixMe: Flow complains about not setting a value, which is intentional here\n\n " --> (669:4-670:0) "\t};" -(1191:4-1191:11) " Object" --> (670:0-670:11) "\n\t\t\t\tObject" -(1191:11-1191:28) ".defineProperties" --> (670:11-670:28) ".defineProperties" -(1191:28-1191:38) "(Consumer," --> (670:28-670:38) "(Consumer," -(1191:38-1192:6) " {\n " --> (670:38-671:5) " {\n\t\t\t\t" -(1192:6-1192:16) " Provider:" --> (671:5-671:15) "\tProvider:" -(1192:16-1193:8) " {\n " --> (671:15-672:6) " {\n\t\t\t\t\t" -(1193:8-1193:13) " get:" --> (672:6-672:11) "\tget:" -(1193:13-1193:25) " function ()" --> (672:11-672:22) " function()" -(1193:25-1194:10) " {\n " --> (672:22-673:0) " {" -(1194:10-1194:15) " if (" --> (673:0-673:12) "\n\t\t\t\t\t\t\tif (" -(1194:15-1194:52) "!hasWarnedAboutUsingConsumerProvider)" --> (673:12-673:49) "!hasWarnedAboutUsingConsumerProvider)" -(1194:52-1195:12) " {\n " --> (673:49-674:0) " {" -(1195:12-1195:50) " hasWarnedAboutUsingConsumerProvider =" --> (674:0-674:46) "\n\t\t\t\t\t\t\t\thasWarnedAboutUsingConsumerProvider =" -(1195:50-1197:12) " true;\n\n " --> (674:46-675:0) " true;" -(1197:12-1197:18) " error" --> (675:0-675:14) "\n\t\t\t\t\t\t\t\terror" -(1197:18-1197:101) "('Rendering is not supported and will be removed in ' +" --> (675:14-675:97) "(\"Rendering is not supported and will be removed in \" +" -(1197:101-1197:178) " 'a future major release. Did you mean to render instead?'" --> (675:97-675:174) " \"a future major release. Did you mean to render instead?\"" -(1197:178-1198:11) ");\n " --> (675:174-676:7) ");\n\t\t\t\t\t\t" -(1198:11-1200:10) "}\n\n " --> (676:7-677:0) "\t}" -(1200:10-1200:17) " return" --> (677:0-677:14) "\n\t\t\t\t\t\t\treturn" -(1200:17-1200:25) " context" --> (677:14-677:22) " context" -(1200:25-1201:9) ".Provider;\n " --> (677:22-678:6) ".Provider;\n\t\t\t\t\t" -(1201:9-1202:8) "},\n " --> (678:6-679:6) "\t},\n\t\t\t\t\t" -(1202:8-1202:13) " set:" --> (679:6-679:11) "\tset:" -(1202:13-1202:23) " function " --> (679:11-679:20) " function" -(1202:23-1202:34) "(_Provider)" --> (679:20-679:31) "(_Provider)" -(1202:34-1203:10) " {\n " --> (679:31-680:0) " {" -(1203:10-1203:18) " context" --> (680:0-680:15) "\n\t\t\t\t\t\t\tcontext" -(1203:18-1203:29) ".Provider =" --> (680:15-680:26) ".Provider =" -(1203:29-1204:9) " _Provider;\n " --> (680:26-681:6) " _Provider;\n\t\t\t\t\t" -(1204:9-1205:7) "}\n " --> (681:6-682:5) "\t}\n\t\t\t\t" -(1205:7-1206:6) "},\n " --> (682:5-683:5) "\t},\n\t\t\t\t" -(1206:6-1206:21) " _currentValue:" --> (683:5-683:20) "\t_currentValue:" -(1206:21-1207:8) " {\n " --> (683:20-684:6) " {\n\t\t\t\t\t" -(1207:8-1207:13) " get:" --> (684:6-684:11) "\tget:" -(1207:13-1207:25) " function ()" --> (684:11-684:22) " function()" -(1207:25-1208:10) " {\n " --> (684:22-685:0) " {" -(1208:10-1208:17) " return" --> (685:0-685:14) "\n\t\t\t\t\t\t\treturn" -(1208:17-1208:25) " context" --> (685:14-685:22) " context" -(1208:25-1209:9) "._currentValue;\n " --> (685:22-686:6) "._currentValue;\n\t\t\t\t\t" -(1209:9-1210:8) "},\n " --> (686:6-687:6) "\t},\n\t\t\t\t\t" -(1210:8-1210:13) " set:" --> (687:6-687:11) "\tset:" -(1210:13-1210:23) " function " --> (687:11-687:20) " function" -(1210:23-1210:38) "(_currentValue)" --> (687:20-687:35) "(_currentValue)" -(1210:38-1211:10) " {\n " --> (687:35-688:0) " {" -(1211:10-1211:18) " context" --> (688:0-688:15) "\n\t\t\t\t\t\t\tcontext" -(1211:18-1211:34) "._currentValue =" --> (688:15-688:31) "._currentValue =" -(1211:34-1212:9) " _currentValue;\n " --> (688:31-689:6) " _currentValue;\n\t\t\t\t\t" -(1212:9-1213:7) "}\n " --> (689:6-690:5) "\t}\n\t\t\t\t" -(1213:7-1214:6) "},\n " --> (690:5-691:5) "\t},\n\t\t\t\t" -(1214:6-1214:22) " _currentValue2:" --> (691:5-691:21) "\t_currentValue2:" -(1214:22-1215:8) " {\n " --> (691:21-692:6) " {\n\t\t\t\t\t" -(1215:8-1215:13) " get:" --> (692:6-692:11) "\tget:" -(1215:13-1215:25) " function ()" --> (692:11-692:22) " function()" -(1215:25-1216:10) " {\n " --> (692:22-693:0) " {" -(1216:10-1216:17) " return" --> (693:0-693:14) "\n\t\t\t\t\t\t\treturn" -(1216:17-1216:25) " context" --> (693:14-693:22) " context" -(1216:25-1217:9) "._currentValue2;\n " --> (693:22-694:6) "._currentValue2;\n\t\t\t\t\t" -(1217:9-1218:8) "},\n " --> (694:6-695:6) "\t},\n\t\t\t\t\t" -(1218:8-1218:13) " set:" --> (695:6-695:11) "\tset:" -(1218:13-1218:23) " function " --> (695:11-695:20) " function" -(1218:23-1218:39) "(_currentValue2)" --> (695:20-695:36) "(_currentValue2)" -(1218:39-1219:10) " {\n " --> (695:36-696:0) " {" -(1219:10-1219:18) " context" --> (696:0-696:15) "\n\t\t\t\t\t\t\tcontext" -(1219:18-1219:35) "._currentValue2 =" --> (696:15-696:32) "._currentValue2 =" -(1219:35-1220:9) " _currentValue2;\n " --> (696:32-697:6) " _currentValue2;\n\t\t\t\t\t" -(1220:9-1221:7) "}\n " --> (697:6-698:5) "\t}\n\t\t\t\t" -(1221:7-1222:6) "},\n " --> (698:5-699:5) "\t},\n\t\t\t\t" -(1222:6-1222:20) " _threadCount:" --> (699:5-699:19) "\t_threadCount:" -(1222:20-1223:8) " {\n " --> (699:19-700:6) " {\n\t\t\t\t\t" -(1223:8-1223:13) " get:" --> (700:6-700:11) "\tget:" -(1223:13-1223:25) " function ()" --> (700:11-700:22) " function()" -(1223:25-1224:10) " {\n " --> (700:22-701:0) " {" -(1224:10-1224:17) " return" --> (701:0-701:14) "\n\t\t\t\t\t\t\treturn" -(1224:17-1224:25) " context" --> (701:14-701:22) " context" -(1224:25-1225:9) "._threadCount;\n " --> (701:22-702:6) "._threadCount;\n\t\t\t\t\t" -(1225:9-1226:8) "},\n " --> (702:6-703:6) "\t},\n\t\t\t\t\t" -(1226:8-1226:13) " set:" --> (703:6-703:11) "\tset:" -(1226:13-1226:23) " function " --> (703:11-703:20) " function" -(1226:23-1226:37) "(_threadCount)" --> (703:20-703:34) "(_threadCount)" -(1226:37-1227:10) " {\n " --> (703:34-704:0) " {" -(1227:10-1227:18) " context" --> (704:0-704:15) "\n\t\t\t\t\t\t\tcontext" -(1227:18-1227:33) "._threadCount =" --> (704:15-704:30) "._threadCount =" -(1227:33-1228:9) " _threadCount;\n " --> (704:30-705:6) " _threadCount;\n\t\t\t\t\t" -(1228:9-1229:7) "}\n " --> (705:6-706:5) "\t}\n\t\t\t\t" -(1229:7-1230:6) "},\n " --> (706:5-707:5) "\t},\n\t\t\t\t" -(1230:6-1230:16) " Consumer:" --> (707:5-707:15) "\tConsumer:" -(1230:16-1231:8) " {\n " --> (707:15-707:17) " {" -(1231:8-1231:13) " get:" --> (707:17-707:22) " get:" -(1231:13-1231:25) " function ()" --> (707:22-707:33) " function()" -(1231:25-1232:10) " {\n " --> (707:33-708:0) " {" -(1232:10-1232:15) " if (" --> (708:0-708:11) "\n\t\t\t\t\t\tif (" -(1232:15-1232:58) "!hasWarnedAboutUsingNestedContextConsumers)" --> (708:11-708:54) "!hasWarnedAboutUsingNestedContextConsumers)" -(1232:58-1233:12) " {\n " --> (708:54-709:0) " {" -(1233:12-1233:56) " hasWarnedAboutUsingNestedContextConsumers =" --> (709:0-709:51) "\n\t\t\t\t\t\t\thasWarnedAboutUsingNestedContextConsumers =" -(1233:56-1235:12) " true;\n\n " --> (709:51-710:0) " true;" -(1235:12-1235:18) " error" --> (710:0-710:13) "\n\t\t\t\t\t\t\terror" -(1235:18-1235:101) "('Rendering is not supported and will be removed in ' +" --> (710:13-710:96) "(\"Rendering is not supported and will be removed in \" +" -(1235:101-1235:178) " 'a future major release. Did you mean to render instead?'" --> (710:96-710:173) " \"a future major release. Did you mean to render instead?\"" -(1235:178-1236:11) ");\n " --> (710:173-711:6) ");\n\t\t\t\t\t" -(1236:11-1238:10) "}\n\n " --> (711:6-712:0) "\t}" -(1238:10-1238:17) " return" --> (712:0-712:13) "\n\t\t\t\t\t\treturn" -(1238:17-1238:25) " context" --> (712:13-712:21) " context" -(1238:25-1239:9) ".Consumer;\n " --> (712:21-713:5) ".Consumer;\n\t\t\t\t" -(1239:9-1240:7) "}\n " --> (713:5-713:7) "\t}" -(1240:7-1241:6) "},\n " --> (713:7-714:5) " },\n\t\t\t\t" -(1241:6-1241:19) " displayName:" --> (714:5-714:18) "\tdisplayName:" -(1241:19-1242:8) " {\n " --> (714:18-715:6) " {\n\t\t\t\t\t" -(1242:8-1242:13) " get:" --> (715:6-715:11) "\tget:" -(1242:13-1242:25) " function ()" --> (715:11-715:22) " function()" -(1242:25-1243:10) " {\n " --> (715:22-716:0) " {" -(1243:10-1243:17) " return" --> (716:0-716:14) "\n\t\t\t\t\t\t\treturn" -(1243:17-1243:25) " context" --> (716:14-716:22) " context" -(1243:25-1244:9) ".displayName;\n " --> (716:22-717:6) ".displayName;\n\t\t\t\t\t" -(1244:9-1245:8) "},\n " --> (717:6-718:6) "\t},\n\t\t\t\t\t" -(1245:8-1245:13) " set:" --> (718:6-718:11) "\tset:" -(1245:13-1245:23) " function " --> (718:11-718:20) " function" -(1245:23-1245:36) "(displayName)" --> (718:20-718:33) "(displayName)" -(1245:36-1246:10) " {\n " --> (718:33-719:0) " {" -(1246:10-1246:15) " if (" --> (719:0-719:12) "\n\t\t\t\t\t\t\tif (" -(1246:15-1246:52) "!hasWarnedAboutDisplayNameOnConsumer)" --> (719:12-719:49) "!hasWarnedAboutDisplayNameOnConsumer)" -(1246:52-1247:12) " {\n " --> (719:49-720:0) " {" -(1247:12-1247:17) " warn" --> (720:0-720:13) "\n\t\t\t\t\t\t\t\twarn" -(1247:17-1247:79) "('Setting `displayName` on Context.Consumer has no effect. ' +" --> (720:13-720:75) "(\"Setting `displayName` on Context.Consumer has no effect. \" +" -(1247:79-1247:157) " \"You should set it directly on the context with Context.displayName = '%s'.\"," --> (720:75-720:153) " \"You should set it directly on the context with Context.displayName = '%s'.\"," -(1247:157-1247:169) " displayName" --> (720:153-720:165) " displayName" -(1247:169-1249:12) ");\n\n " --> (720:165-721:0) ");" -(1249:12-1249:50) " hasWarnedAboutDisplayNameOnConsumer =" --> (721:0-721:46) "\n\t\t\t\t\t\t\t\thasWarnedAboutDisplayNameOnConsumer =" -(1249:50-1250:11) " true;\n " --> (721:46-722:7) " true;\n\t\t\t\t\t\t" -(1250:11-1251:9) "}\n " --> (722:7-723:6) "\t}\n\t\t\t\t\t" -(1251:9-1252:7) "}\n " --> (723:6-724:5) "\t}\n\t\t\t\t" -(1252:7-1253:5) "}\n " --> (724:5-725:4) "\t}\n\t\t\t" -(1253:5-1253:6) "}" --> (725:4-725:6) "\t}" -(1253:6-1255:4) "); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\n\n " --> (725:6-726:0) ");" -(1255:4-1255:12) " context" --> (726:0-726:12) "\n\t\t\t\tcontext" -(1255:12-1255:23) ".Consumer =" --> (726:12-726:23) ".Consumer =" -(1255:23-1256:3) " Consumer;\n " --> (726:23-727:3) " Consumer;\n\t\t" -(1256:3-1258:2) "}\n\n " --> (727:3-728:3) "\t}\n\t\t" -(1258:2-1259:4) " {\n " --> (728:3-729:0) "\t{" -(1259:4-1259:12) " context" --> (729:0-729:12) "\n\t\t\t\tcontext" -(1259:12-1259:31) "._currentRenderer =" --> (729:12-729:31) "._currentRenderer =" -(1259:31-1260:4) " null;\n " --> (729:31-730:0) " null;" -(1260:4-1260:12) " context" --> (730:0-730:12) "\n\t\t\t\tcontext" -(1260:12-1260:32) "._currentRenderer2 =" --> (730:12-730:32) "._currentRenderer2 =" -(1260:32-1261:3) " null;\n " --> (730:32-731:3) " null;\n\t\t" -(1261:3-1263:2) "}\n\n " --> (731:3-732:0) "\t}" -(1263:2-1263:9) " return" --> (732:0-732:10) "\n\t\t\treturn" -(1263:9-1264:1) " context;\n" --> (732:10-733:2) " context;\n\t" -(1264:1-1266:0) "}\n" --> (733:2-734:2) "\t}\n\t" -(1266:0-1266:4) "\nvar" --> (734:2-734:6) "\tvar" -(1266:4-1266:21) " Uninitialized = " --> (734:6-734:23) " Uninitialized = " -(1266:21-1267:0) "-1;" --> (734:23-735:2) "-1;\n\t" -(1267:0-1267:4) "\nvar" --> (735:2-735:6) "\tvar" -(1267:4-1267:14) " Pending =" --> (735:6-735:16) " Pending =" -(1267:14-1268:0) " 0;" --> (735:16-736:2) " 0;\n\t" -(1268:0-1268:4) "\nvar" --> (736:2-736:6) "\tvar" -(1268:4-1268:15) " Resolved =" --> (736:6-736:17) " Resolved =" -(1268:15-1269:0) " 1;" --> (736:17-737:2) " 1;\n\t" -(1269:0-1269:4) "\nvar" --> (737:2-737:6) "\tvar" -(1269:4-1269:15) " Rejected =" --> (737:6-737:17) " Rejected =" -(1269:15-1271:0) " 2;\n" --> (737:17-738:2) " 2;\n\t" -(1271:0-1271:9) "\nfunction" --> (738:2-738:11) "\tfunction" -(1271:9-1271:25) " lazyInitializer" --> (738:11-738:27) " lazyInitializer" -(1271:25-1271:34) "(payload)" --> (738:27-738:36) "(payload)" -(1271:34-1272:2) " {\n " --> (738:36-739:0) " {" -(1272:2-1272:6) " if " --> (739:0-739:7) "\n\t\t\tif " -(1272:6-1272:14) "(payload" --> (739:7-739:15) "(payload" -(1272:14-1272:26) "._status ===" --> (739:15-739:27) "._status ===" -(1272:26-1272:41) " Uninitialized)" --> (739:27-739:42) " Uninitialized)" -(1272:41-1273:4) " {\n " --> (739:42-740:4) " {\n\t\t\t" -(1273:4-1273:8) " var" --> (740:4-740:8) "\tvar" -(1273:8-1273:15) " ctor =" --> (740:8-740:15) " ctor =" -(1273:15-1273:23) " payload" --> (740:15-740:23) " payload" -(1273:23-1274:4) "._result;\n " --> (740:23-741:4) "._result;\n\t\t\t" -(1274:4-1274:8) " var" --> (741:4-741:8) "\tvar" -(1274:8-1274:19) " thenable =" --> (741:8-741:19) " thenable =" -(1274:19-1274:25) " ctor(" --> (741:19-741:25) " ctor(" -(1274:25-1276:4) "); // Transition to the next state.\n\n " --> (741:25-742:4) ");\n\t\t\t" -(1276:4-1276:8) " var" --> (742:4-742:8) "\tvar" -(1276:8-1276:18) " pending =" --> (742:8-742:18) " pending =" -(1276:18-1277:4) " payload;\n " --> (742:18-743:0) " payload;" -(1277:4-1277:12) " pending" --> (743:0-743:12) "\n\t\t\t\tpending" -(1277:12-1277:22) "._status =" --> (743:12-743:22) "._status =" -(1277:22-1278:4) " Pending;\n " --> (743:22-744:0) " Pending;" -(1278:4-1278:12) " pending" --> (744:0-744:12) "\n\t\t\t\tpending" -(1278:12-1278:22) "._result =" --> (744:12-744:22) "._result =" -(1278:22-1279:4) " thenable;\n " --> (744:22-745:0) " thenable;" -(1279:4-1279:13) " thenable" --> (745:0-745:13) "\n\t\t\t\tthenable" -(1279:13-1279:18) ".then" --> (745:13-745:18) ".then" -(1279:18-1279:28) "(function " --> (745:18-745:27) "(function" -(1279:28-1279:42) "(moduleObject)" --> (745:27-745:41) "(moduleObject)" -(1279:42-1280:6) " {\n " --> (745:41-746:0) " {" -(1280:6-1280:10) " if " --> (746:0-746:9) "\n\t\t\t\t\tif " -(1280:10-1280:18) "(payload" --> (746:9-746:17) "(payload" -(1280:18-1280:30) "._status ===" --> (746:17-746:29) "._status ===" -(1280:30-1280:39) " Pending)" --> (746:29-746:38) " Pending)" -(1280:39-1281:8) " {\n " --> (746:38-747:6) " {\n\t\t\t\t\t" -(1281:8-1281:12) " var" --> (747:6-747:10) "\tvar" -(1281:12-1281:28) " defaultExport =" --> (747:10-747:26) " defaultExport =" -(1281:28-1281:41) " moduleObject" --> (747:26-747:39) " moduleObject" -(1281:41-1283:8) ".default;\n\n " --> (747:39-748:6) ".default;\n\t\t\t\t\t" -(1283:8-1284:10) " {\n " --> (748:6-749:0) "\t{" -(1284:10-1284:14) " if " --> (749:0-749:11) "\n\t\t\t\t\t\t\tif " -(1284:14-1284:32) "(defaultExport ===" --> (749:11-749:29) "(defaultExport ===" -(1284:32-1284:43) " undefined)" --> (749:29-749:40) " undefined)" -(1284:43-1285:12) " {\n " --> (749:40-750:0) " {" -(1285:12-1285:18) " error" --> (750:0-750:14) "\n\t\t\t\t\t\t\t\terror" -(1285:18-1285:77) "('lazy: Expected the result of a dynamic import() call. ' +" --> (750:14-750:73) "(\"lazy: Expected the result of a dynamic import() call. \" +" -(1285:77-1286:12) " 'Instead received: %s\\n\\nYour code should look like: \\n ' + // Break up imports to avoid accidentally parsing them as dependencies.\n " --> (750:73-750:134) " \"Instead received: %s\\n\\nYour code should look like: \\n \" +" -(1286:12-1286:51) " 'const MyComponent = lazy(() => imp' +" --> (750:134-750:173) " \"const MyComponent = lazy(() => imp\" +" -(1286:51-1286:76) " \"ort('./MyComponent'))\"," --> (750:173-750:198) " \"ort('./MyComponent'))\"," -(1286:76-1286:89) " moduleObject" --> (750:198-750:211) " moduleObject" -(1286:89-1287:11) ");\n " --> (750:211-751:7) ");\n\t\t\t\t\t\t" -(1287:11-1288:9) "}\n " --> (751:7-752:6) "\t}\n\t\t\t\t\t" -(1288:9-1291:8) "} // Transition to the next state.\n\n\n " --> (752:6-753:6) "\t}\n\t\t\t\t\t" -(1291:8-1291:12) " var" --> (753:6-753:10) "\tvar" -(1291:12-1291:23) " resolved =" --> (753:10-753:21) " resolved =" -(1291:23-1292:8) " payload;\n " --> (753:21-754:0) " payload;" -(1292:8-1292:17) " resolved" --> (754:0-754:15) "\n\t\t\t\t\t\tresolved" -(1292:17-1292:27) "._status =" --> (754:15-754:25) "._status =" -(1292:27-1293:8) " Resolved;\n " --> (754:25-755:0) " Resolved;" -(1293:8-1293:17) " resolved" --> (755:0-755:15) "\n\t\t\t\t\t\tresolved" -(1293:17-1293:27) "._result =" --> (755:15-755:25) "._result =" -(1293:27-1294:7) " defaultExport;\n " --> (755:25-756:5) " defaultExport;\n\t\t\t\t" -(1294:7-1295:5) "}\n " --> (756:5-757:4) "\t}\n\t\t\t" -(1295:5-1295:7) "}," --> (757:4-757:7) "\t}," -(1295:7-1295:17) " function " --> (757:7-757:16) " function" -(1295:17-1295:24) "(error)" --> (757:16-757:23) "(error)" -(1295:24-1296:6) " {\n " --> (757:23-758:0) " {" -(1296:6-1296:10) " if " --> (758:0-758:9) "\n\t\t\t\t\tif " -(1296:10-1296:18) "(payload" --> (758:9-758:17) "(payload" -(1296:18-1296:30) "._status ===" --> (758:17-758:29) "._status ===" -(1296:30-1296:39) " Pending)" --> (758:29-758:38) " Pending)" -(1296:39-1298:8) " {\n // Transition to the next state.\n " --> (758:38-759:6) " {\n\t\t\t\t\t" -(1298:8-1298:12) " var" --> (759:6-759:10) "\tvar" -(1298:12-1298:23) " rejected =" --> (759:10-759:21) " rejected =" -(1298:23-1299:8) " payload;\n " --> (759:21-760:0) " payload;" -(1299:8-1299:17) " rejected" --> (760:0-760:15) "\n\t\t\t\t\t\trejected" -(1299:17-1299:27) "._status =" --> (760:15-760:25) "._status =" -(1299:27-1300:8) " Rejected;\n " --> (760:25-761:0) " Rejected;" -(1300:8-1300:17) " rejected" --> (761:0-761:15) "\n\t\t\t\t\t\trejected" -(1300:17-1300:27) "._result =" --> (761:15-761:25) "._result =" -(1300:27-1301:7) " error;\n " --> (761:25-762:5) " error;\n\t\t\t\t" -(1301:7-1302:5) "}\n " --> (762:5-763:4) "\t}\n\t\t\t" -(1302:5-1302:6) "}" --> (763:4-763:6) "\t}" -(1302:6-1303:3) ");\n " --> (763:6-764:3) ");\n\t\t" -(1303:3-1305:2) "}\n\n " --> (764:3-765:0) "\t}" -(1305:2-1305:6) " if " --> (765:0-765:7) "\n\t\t\tif " -(1305:6-1305:14) "(payload" --> (765:7-765:15) "(payload" -(1305:14-1305:26) "._status ===" --> (765:15-765:27) "._status ===" -(1305:26-1305:36) " Resolved)" --> (765:27-765:37) " Resolved)" -(1305:36-1306:4) " {\n " --> (765:37-766:0) " {" -(1306:4-1306:11) " return" --> (766:0-766:11) "\n\t\t\t\treturn" -(1306:11-1306:19) " payload" --> (766:11-766:19) " payload" -(1306:19-1307:3) "._result;\n " --> (766:19-767:3) "._result;\n\t\t" -(1307:3-1307:9) "} else" --> (767:3-767:10) "\t} else" -(1307:9-1308:4) " {\n " --> (767:10-768:0) " {" -(1308:4-1308:10) " throw" --> (768:0-768:10) "\n\t\t\t\tthrow" -(1308:10-1308:18) " payload" --> (768:10-768:18) " payload" -(1308:18-1309:3) "._result;\n " --> (768:18-769:3) "._result;\n\t\t" -(1309:3-1310:1) "}\n" --> (769:3-770:2) "\t}\n\t" -(1310:1-1312:0) "}\n" --> (770:2-771:2) "\t}\n\t" -(1312:0-1312:9) "\nfunction" --> (771:2-771:11) "\tfunction" -(1312:9-1312:14) " lazy" --> (771:11-771:16) " lazy" -(1312:14-1312:20) "(ctor)" --> (771:16-771:22) "(ctor)" -(1312:20-1313:2) " {\n " --> (771:22-772:3) " {\n\t\t" -(1313:2-1313:6) " var" --> (772:3-772:7) "\tvar" -(1313:6-1313:16) " payload =" --> (772:7-772:17) " payload =" -(1313:16-1315:4) " {\n // We use these fields to store the result.\n " --> (772:17-773:4) " {\n\t\t\t" -(1315:4-1315:14) " _status: " --> (773:4-773:14) "\t_status: " -(1315:14-1316:4) "-1,\n " --> (773:14-774:4) "-1,\n\t\t\t" -(1316:4-1316:13) " _result:" --> (774:4-774:13) "\t_result:" -(1316:13-1317:3) " ctor\n " --> (774:13-775:3) " ctor\n\t\t" -(1317:3-1318:2) "};\n " --> (775:3-776:3) "\t};\n\t\t" -(1318:2-1318:6) " var" --> (776:3-776:7) "\tvar" -(1318:6-1318:17) " lazyType =" --> (776:7-776:18) " lazyType =" -(1318:17-1319:4) " {\n " --> (776:18-777:4) " {\n\t\t\t" -(1319:4-1319:14) " $$typeof:" --> (777:4-777:14) "\t$$typeof:" -(1319:14-1320:4) " REACT_LAZY_TYPE,\n " --> (777:14-778:4) " REACT_LAZY_TYPE,\n\t\t\t" -(1320:4-1320:14) " _payload:" --> (778:4-778:14) "\t_payload:" -(1320:14-1321:4) " payload,\n " --> (778:14-779:4) " payload,\n\t\t\t" -(1321:4-1321:11) " _init:" --> (779:4-779:11) "\t_init:" -(1321:11-1322:3) " lazyInitializer\n " --> (779:11-780:3) " lazyInitializer\n\t\t" -(1322:3-1324:2) "};\n\n " --> (780:3-781:3) "\t};\n\t\t" -(1324:2-1326:4) " {\n // In production, this would just set it on the object.\n " --> (781:3-782:4) "\t{\n\t\t\t" -(1326:4-1326:8) " var" --> (782:4-782:8) "\tvar" -(1326:8-1327:4) " defaultProps;\n " --> (782:8-783:4) " defaultProps;\n\t\t\t" -(1327:4-1327:8) " var" --> (783:4-783:8) "\tvar" -(1327:8-1329:4) " propTypes; // $FlowFixMe\n\n " --> (783:8-784:0) " propTypes;" -(1329:4-1329:11) " Object" --> (784:0-784:11) "\n\t\t\t\tObject" -(1329:11-1329:28) ".defineProperties" --> (784:11-784:28) ".defineProperties" -(1329:28-1329:38) "(lazyType," --> (784:28-784:38) "(lazyType," -(1329:38-1330:6) " {\n " --> (784:38-785:5) " {\n\t\t\t\t" -(1330:6-1330:20) " defaultProps:" --> (785:5-785:19) "\tdefaultProps:" -(1330:20-1331:8) " {\n " --> (785:19-786:6) " {\n\t\t\t\t\t" -(1331:8-1331:22) " configurable:" --> (786:6-786:20) "\tconfigurable:" -(1331:22-1332:8) " true,\n " --> (786:20-787:6) " true,\n\t\t\t\t\t" -(1332:8-1332:13) " get:" --> (787:6-787:11) "\tget:" -(1332:13-1332:25) " function ()" --> (787:11-787:22) " function()" -(1332:25-1333:10) " {\n " --> (787:22-788:0) " {" -(1333:10-1333:17) " return" --> (788:0-788:14) "\n\t\t\t\t\t\t\treturn" -(1333:17-1334:9) " defaultProps;\n " --> (788:14-789:6) " defaultProps;\n\t\t\t\t\t" -(1334:9-1335:8) "},\n " --> (789:6-790:6) "\t},\n\t\t\t\t\t" -(1335:8-1335:13) " set:" --> (790:6-790:11) "\tset:" -(1335:13-1335:23) " function " --> (790:11-790:20) " function" -(1335:23-1335:40) "(newDefaultProps)" --> (790:20-790:37) "(newDefaultProps)" -(1335:40-1336:10) " {\n " --> (790:37-791:0) " {" -(1336:10-1336:16) " error" --> (791:0-791:13) "\n\t\t\t\t\t\t\terror" -(1336:16-1336:86) "('React.lazy(...): It is not supported to assign `defaultProps` to ' +" --> (791:13-791:83) "(\"React.lazy(...): It is not supported to assign `defaultProps` to \" +" -(1336:86-1336:156) " 'a lazy component import. Either specify them where the component ' +" --> (791:83-791:153) " \"a lazy component import. Either specify them where the component \" +" -(1336:156-1336:212) " 'is defined, or create a wrapping component around it.'" --> (791:153-791:209) " \"is defined, or create a wrapping component around it.\"" -(1336:212-1338:10) ");\n\n " --> (791:209-792:0) ");" -(1338:10-1338:25) " defaultProps =" --> (792:0-792:22) "\n\t\t\t\t\t\t\tdefaultProps =" -(1338:25-1341:10) " newDefaultProps; // Match production behavior more closely:\n // $FlowFixMe\n\n " --> (792:22-793:0) " newDefaultProps;" -(1341:10-1341:17) " Object" --> (793:0-793:14) "\n\t\t\t\t\t\t\tObject" -(1341:17-1341:32) ".defineProperty" --> (793:14-793:29) ".defineProperty" -(1341:32-1341:42) "(lazyType," --> (793:29-793:39) "(lazyType," -(1341:42-1341:58) " 'defaultProps'," --> (793:39-793:55) " \"defaultProps\"," -(1341:58-1342:12) " {\n " --> (793:55-793:57) " {" -(1342:12-1342:24) " enumerable:" --> (793:57-793:69) " enumerable:" -(1342:24-1343:11) " true\n " --> (793:69-793:74) " true" -(1343:11-1343:12) "}" --> (793:74-793:76) " }" -(1343:12-1344:9) ");\n " --> (793:76-794:6) ");\n\t\t\t\t\t" -(1344:9-1345:7) "}\n " --> (794:6-795:5) "\t}\n\t\t\t\t" -(1345:7-1346:6) "},\n " --> (795:5-796:5) "\t},\n\t\t\t\t" -(1346:6-1346:17) " propTypes:" --> (796:5-796:16) "\tpropTypes:" -(1346:17-1347:8) " {\n " --> (796:16-797:6) " {\n\t\t\t\t\t" -(1347:8-1347:22) " configurable:" --> (797:6-797:20) "\tconfigurable:" -(1347:22-1348:8) " true,\n " --> (797:20-798:6) " true,\n\t\t\t\t\t" -(1348:8-1348:13) " get:" --> (798:6-798:11) "\tget:" -(1348:13-1348:25) " function ()" --> (798:11-798:22) " function()" -(1348:25-1349:10) " {\n " --> (798:22-799:0) " {" -(1349:10-1349:17) " return" --> (799:0-799:14) "\n\t\t\t\t\t\t\treturn" -(1349:17-1350:9) " propTypes;\n " --> (799:14-800:6) " propTypes;\n\t\t\t\t\t" -(1350:9-1351:8) "},\n " --> (800:6-801:6) "\t},\n\t\t\t\t\t" -(1351:8-1351:13) " set:" --> (801:6-801:11) "\tset:" -(1351:13-1351:23) " function " --> (801:11-801:20) " function" -(1351:23-1351:37) "(newPropTypes)" --> (801:20-801:34) "(newPropTypes)" -(1351:37-1352:10) " {\n " --> (801:34-802:0) " {" -(1352:10-1352:16) " error" --> (802:0-802:13) "\n\t\t\t\t\t\t\terror" -(1352:16-1352:83) "('React.lazy(...): It is not supported to assign `propTypes` to ' +" --> (802:13-802:80) "(\"React.lazy(...): It is not supported to assign `propTypes` to \" +" -(1352:83-1352:153) " 'a lazy component import. Either specify them where the component ' +" --> (802:80-802:150) " \"a lazy component import. Either specify them where the component \" +" -(1352:153-1352:209) " 'is defined, or create a wrapping component around it.'" --> (802:150-802:206) " \"is defined, or create a wrapping component around it.\"" -(1352:209-1354:10) ");\n\n " --> (802:206-803:0) ");" -(1354:10-1354:22) " propTypes =" --> (803:0-803:19) "\n\t\t\t\t\t\t\tpropTypes =" -(1354:22-1357:10) " newPropTypes; // Match production behavior more closely:\n // $FlowFixMe\n\n " --> (803:19-804:0) " newPropTypes;" -(1357:10-1357:17) " Object" --> (804:0-804:14) "\n\t\t\t\t\t\t\tObject" -(1357:17-1357:32) ".defineProperty" --> (804:14-804:29) ".defineProperty" -(1357:32-1357:42) "(lazyType," --> (804:29-804:39) "(lazyType," -(1357:42-1357:55) " 'propTypes'," --> (804:39-804:52) " \"propTypes\"," -(1357:55-1358:12) " {\n " --> (804:52-804:54) " {" -(1358:12-1358:24) " enumerable:" --> (804:54-804:66) " enumerable:" -(1358:24-1359:11) " true\n " --> (804:66-804:71) " true" -(1359:11-1359:12) "}" --> (804:71-804:73) " }" -(1359:12-1360:9) ");\n " --> (804:73-805:6) ");\n\t\t\t\t\t" -(1360:9-1361:7) "}\n " --> (805:6-806:5) "\t}\n\t\t\t\t" -(1361:7-1362:5) "}\n " --> (806:5-807:4) "\t}\n\t\t\t" -(1362:5-1362:6) "}" --> (807:4-807:6) "\t}" -(1362:6-1363:3) ");\n " --> (807:6-808:3) ");\n\t\t" -(1363:3-1365:2) "}\n\n " --> (808:3-809:0) "\t}" -(1365:2-1365:9) " return" --> (809:0-809:10) "\n\t\t\treturn" -(1365:9-1366:1) " lazyType;\n" --> (809:10-810:2) " lazyType;\n\t" -(1366:1-1368:0) "}\n" --> (810:2-811:2) "\t}\n\t" -(1368:0-1368:9) "\nfunction" --> (811:2-811:11) "\tfunction" -(1368:9-1368:20) " forwardRef" --> (811:11-811:22) " forwardRef" -(1368:20-1368:28) "(render)" --> (811:22-811:30) "(render)" -(1368:28-1369:2) " {\n " --> (811:30-812:3) " {\n\t\t" -(1369:2-1370:4) " {\n " --> (812:3-813:0) "\t{" -(1370:4-1370:8) " if " --> (813:0-813:8) "\n\t\t\t\tif " -(1370:8-1370:18) "(render !=" --> (813:8-813:18) "(render !=" -(1370:18-1370:26) " null &&" --> (813:18-813:26) " null &&" -(1370:26-1370:33) " render" --> (813:26-813:33) " render" -(1370:33-1370:46) ".$$typeof ===" --> (813:33-813:46) ".$$typeof ===" -(1370:46-1370:63) " REACT_MEMO_TYPE)" --> (813:46-813:63) " REACT_MEMO_TYPE)" -(1370:63-1371:6) " {\n " --> (813:63-814:0) " {" -(1371:6-1371:12) " error" --> (814:0-814:11) "\n\t\t\t\t\terror" -(1371:12-1371:77) "('forwardRef requires a render function but received a `memo` ' +" --> (814:11-814:76) "(\"forwardRef requires a render function but received a `memo` \" +" -(1371:77-1371:131) " 'component. Instead of forwardRef(memo(...)), use ' +" --> (814:76-814:130) " \"component. Instead of forwardRef(memo(...)), use \" +" -(1371:131-1371:156) " 'memo(forwardRef(...)).'" --> (814:130-814:155) " \"memo(forwardRef(...)).\"" -(1371:156-1372:5) ");\n " --> (814:155-815:4) ");\n\t\t\t" -(1372:5-1372:22) "} else if (typeof" --> (815:4-815:22) "\t} else if (typeof" -(1372:22-1372:33) " render !==" --> (815:22-815:33) " render !==" -(1372:33-1372:45) " 'function')" --> (815:33-815:45) " \"function\")" -(1372:45-1373:6) " {\n " --> (815:45-816:0) " {" -(1373:6-1373:12) " error" --> (816:0-816:11) "\n\t\t\t\t\terror" -(1373:12-1373:71) "('forwardRef requires a render function but was given %s.'," --> (816:11-816:70) "(\"forwardRef requires a render function but was given %s.\"," -(1373:71-1373:82) " render ===" --> (816:70-816:81) " render ===" -(1373:82-1373:89) " null ?" --> (816:81-816:88) " null ?" -(1373:89-1373:105) " 'null' : typeof" --> (816:88-816:104) " \"null\" : typeof" -(1373:105-1373:112) " render" --> (816:104-816:111) " render" -(1373:112-1374:5) ");\n " --> (816:111-817:4) ");\n\t\t\t" -(1374:5-1374:11) "} else" --> (817:4-817:11) "\t} else" -(1374:11-1375:6) " {\n " --> (817:11-818:0) " {" -(1375:6-1375:10) " if " --> (818:0-818:9) "\n\t\t\t\t\tif " -(1375:10-1375:17) "(render" --> (818:9-818:16) "(render" -(1375:17-1375:28) ".length !==" --> (818:16-818:27) ".length !==" -(1375:28-1375:33) " 0 &&" --> (818:27-818:32) " 0 &&" -(1375:33-1375:40) " render" --> (818:32-818:39) " render" -(1375:40-1375:51) ".length !==" --> (818:39-818:50) ".length !==" -(1375:51-1375:54) " 2)" --> (818:50-818:53) " 2)" -(1375:54-1376:8) " {\n " --> (818:53-819:0) " {" -(1376:8-1376:14) " error" --> (819:0-819:12) "\n\t\t\t\t\t\terror" -(1376:14-1376:94) "('forwardRef render functions accept exactly two parameters: props and ref. %s'," --> (819:12-819:92) "(\"forwardRef render functions accept exactly two parameters: props and ref. %s\"," -(1376:94-1376:101) " render" --> (819:92-819:99) " render" -(1376:101-1376:112) ".length ===" --> (819:99-819:110) ".length ===" -(1376:112-1376:116) " 1 ?" --> (819:110-819:114) " 1 ?" -(1376:116-1376:161) " 'Did you forget to use the ref parameter?' :" --> (819:114-819:159) " \"Did you forget to use the ref parameter?\" :" -(1376:161-1376:207) " 'Any additional parameter will be undefined.'" --> (819:159-819:205) " \"Any additional parameter will be undefined.\"" -(1376:207-1377:7) ");\n " --> (819:205-820:5) ");\n\t\t\t\t" -(1377:7-1378:5) "}\n " --> (820:5-821:4) "\t}\n\t\t\t" -(1378:5-1380:4) "}\n\n " --> (821:4-822:0) "\t}" -(1380:4-1380:8) " if " --> (822:0-822:8) "\n\t\t\t\tif " -(1380:8-1380:18) "(render !=" --> (822:8-822:18) "(render !=" -(1380:18-1380:24) " null)" --> (822:18-822:24) " null)" -(1380:24-1381:6) " {\n " --> (822:24-823:0) " {" -(1381:6-1381:10) " if " --> (823:0-823:9) "\n\t\t\t\t\tif " -(1381:10-1381:17) "(render" --> (823:9-823:16) "(render" -(1381:17-1381:33) ".defaultProps !=" --> (823:16-823:32) ".defaultProps !=" -(1381:33-1381:41) " null ||" --> (823:32-823:40) " null ||" -(1381:41-1381:48) " render" --> (823:40-823:47) " render" -(1381:48-1381:61) ".propTypes !=" --> (823:47-823:60) ".propTypes !=" -(1381:61-1381:67) " null)" --> (823:60-823:66) " null)" -(1381:67-1382:8) " {\n " --> (823:66-824:0) " {" -(1382:8-1382:14) " error" --> (824:0-824:12) "\n\t\t\t\t\t\terror" -(1382:14-1382:89) "('forwardRef render functions do not support propTypes or defaultProps. ' +" --> (824:12-824:87) "(\"forwardRef render functions do not support propTypes or defaultProps. \" +" -(1382:89-1382:136) " 'Did you accidentally pass a React component?'" --> (824:87-824:134) " \"Did you accidentally pass a React component?\"" -(1382:136-1383:7) ");\n " --> (824:134-825:5) ");\n\t\t\t\t" -(1383:7-1384:5) "}\n " --> (825:5-826:4) "\t}\n\t\t\t" -(1384:5-1385:3) "}\n " --> (826:4-827:3) "\t}\n\t\t" -(1385:3-1387:2) "}\n\n " --> (827:3-828:3) "\t}\n\t\t" -(1387:2-1387:6) " var" --> (828:3-828:7) "\tvar" -(1387:6-1387:20) " elementType =" --> (828:7-828:21) " elementType =" -(1387:20-1388:4) " {\n " --> (828:21-829:4) " {\n\t\t\t" -(1388:4-1388:14) " $$typeof:" --> (829:4-829:14) "\t$$typeof:" -(1388:14-1389:12) " REACT_FORWARD_REF_TYPE,\n render:" --> (829:14-830:4) " REACT_FORWARD_REF_TYPE,\n\t\t\t" -(1389:12-1390:3) " render\n " --> (830:4-831:3) "\trender\n\t\t" -(1390:3-1392:2) "};\n\n " --> (831:3-832:3) "\t};\n\t\t" -(1392:2-1393:4) " {\n " --> (832:3-833:4) "\t{\n\t\t\t" -(1393:4-1393:8) " var" --> (833:4-833:8) "\tvar" -(1393:8-1394:4) " ownName;\n " --> (833:8-834:0) " ownName;" -(1394:4-1394:11) " Object" --> (834:0-834:11) "\n\t\t\t\tObject" -(1394:11-1394:26) ".defineProperty" --> (834:11-834:26) ".defineProperty" -(1394:26-1394:39) "(elementType," --> (834:26-834:39) "(elementType," -(1394:39-1394:54) " 'displayName'," --> (834:39-834:54) " \"displayName\"," -(1394:54-1395:6) " {\n " --> (834:54-835:5) " {\n\t\t\t\t" -(1395:6-1395:18) " enumerable:" --> (835:5-835:17) "\tenumerable:" -(1395:18-1396:6) " false,\n " --> (835:17-836:5) " false,\n\t\t\t\t" -(1396:6-1396:20) " configurable:" --> (836:5-836:19) "\tconfigurable:" -(1396:20-1397:6) " true,\n " --> (836:19-837:5) " true,\n\t\t\t\t" -(1397:6-1397:11) " get:" --> (837:5-837:10) "\tget:" -(1397:11-1397:23) " function ()" --> (837:10-837:21) " function()" -(1397:23-1398:8) " {\n " --> (837:21-838:0) " {" -(1398:8-1398:15) " return" --> (838:0-838:13) "\n\t\t\t\t\t\treturn" -(1398:15-1399:7) " ownName;\n " --> (838:13-839:5) " ownName;\n\t\t\t\t" -(1399:7-1400:6) "},\n " --> (839:5-840:5) "\t},\n\t\t\t\t" -(1400:6-1400:11) " set:" --> (840:5-840:10) "\tset:" -(1400:11-1400:21) " function " --> (840:10-840:19) " function" -(1400:21-1400:27) "(name)" --> (840:19-840:25) "(name)" -(1400:27-1401:8) " {\n " --> (840:25-841:0) " {" -(1401:8-1401:18) " ownName =" --> (841:0-841:16) "\n\t\t\t\t\t\townName =" -(1401:18-1403:8) " name;\n\n " --> (841:16-842:0) " name;" -(1403:8-1403:12) " if " --> (842:0-842:10) "\n\t\t\t\t\t\tif " -(1403:12-1403:19) "(render" --> (842:10-842:17) "(render" -(1403:19-1403:34) ".displayName ==" --> (842:17-842:32) ".displayName ==" -(1403:34-1403:40) " null)" --> (842:32-842:38) " null)" -(1403:40-1404:10) " {\n " --> (842:38-843:0) " {" -(1404:10-1404:17) " render" --> (843:0-843:14) "\n\t\t\t\t\t\t\trender" -(1404:17-1404:31) ".displayName =" --> (843:14-843:28) ".displayName =" -(1404:31-1405:9) " name;\n " --> (843:28-844:6) " name;\n\t\t\t\t\t" -(1405:9-1406:7) "}\n " --> (844:6-845:5) "\t}\n\t\t\t\t" -(1406:7-1407:5) "}\n " --> (845:5-846:4) "\t}\n\t\t\t" -(1407:5-1407:6) "}" --> (846:4-846:6) "\t}" -(1407:6-1408:3) ");\n " --> (846:6-847:3) ");\n\t\t" -(1408:3-1410:2) "}\n\n " --> (847:3-848:0) "\t}" -(1410:2-1410:9) " return" --> (848:0-848:10) "\n\t\t\treturn" -(1410:9-1411:1) " elementType;\n" --> (848:10-849:2) " elementType;\n\t" -(1411:1-1415:0) "}\n\n// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.\n" --> (849:2-850:2) "\t}\n\t" -(1415:0-1415:4) "\nvar" --> (850:2-850:6) "\tvar" -(1415:4-1415:21) " enableScopeAPI =" --> (850:6-850:23) " enableScopeAPI =" -(1415:21-1417:0) " false; // Experimental Create Event Handle API.\n" --> (850:23-851:2) " false;\n\t" -(1417:0-1417:9) "\nfunction" --> (851:2-851:11) "\tfunction" -(1417:9-1417:28) " isValidElementType" --> (851:11-851:30) " isValidElementType" -(1417:28-1417:34) "(type)" --> (851:30-851:36) "(type)" -(1417:34-1418:2) " {\n " --> (851:36-852:0) " {" -(1418:2-1418:13) " if (typeof" --> (852:0-852:14) "\n\t\t\tif (typeof" -(1418:13-1418:22) " type ===" --> (852:14-852:23) " type ===" -(1418:22-1418:41) " 'string' || typeof" --> (852:23-852:42) " \"string\" || typeof" -(1418:41-1418:50) " type ===" --> (852:42-852:51) " type ===" -(1418:50-1418:62) " 'function')" --> (852:51-852:63) " \"function\")" -(1418:62-1419:4) " {\n " --> (852:63-853:0) " {" -(1419:4-1419:11) " return" --> (853:0-853:11) "\n\t\t\t\treturn" -(1419:11-1420:3) " true;\n " --> (853:11-854:3) " true;\n\t\t" -(1420:3-1423:2) "} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).\n\n\n " --> (854:3-855:0) "\t}" -(1423:2-1423:6) " if " --> (855:0-855:7) "\n\t\t\tif " -(1423:6-1423:15) "(type ===" --> (855:7-855:16) "(type ===" -(1423:15-1423:23) " exports" --> (855:16-855:24) " exports" -(1423:23-1423:35) ".Fragment ||" --> (855:24-855:36) ".Fragment ||" -(1423:35-1423:44) " type ===" --> (855:36-855:45) " type ===" -(1423:44-1423:52) " exports" --> (855:45-855:53) " exports" -(1423:52-1423:64) ".Profiler ||" --> (855:53-855:65) ".Profiler ||" -(1423:64-1423:73) " type ===" --> (855:65-855:74) " type ===" -(1423:73-1423:106) " REACT_DEBUG_TRACING_MODE_TYPE ||" --> (855:74-855:107) " REACT_DEBUG_TRACING_MODE_TYPE ||" -(1423:106-1423:115) " type ===" --> (855:107-855:116) " type ===" -(1423:115-1423:123) " exports" --> (855:116-855:124) " exports" -(1423:123-1423:137) ".StrictMode ||" --> (855:124-855:138) ".StrictMode ||" -(1423:137-1423:146) " type ===" --> (855:138-855:147) " type ===" -(1423:146-1423:154) " exports" --> (855:147-855:155) " exports" -(1423:154-1423:166) ".Suspense ||" --> (855:155-855:167) ".Suspense ||" -(1423:166-1423:175) " type ===" --> (855:167-855:176) " type ===" -(1423:175-1423:203) " REACT_SUSPENSE_LIST_TYPE ||" --> (855:176-855:204) " REACT_SUSPENSE_LIST_TYPE ||" -(1423:203-1423:212) " type ===" --> (855:204-855:213) " type ===" -(1423:212-1423:240) " REACT_LEGACY_HIDDEN_TYPE ||" --> (855:213-855:241) " REACT_LEGACY_HIDDEN_TYPE ||" -(1423:240-1423:257) " enableScopeAPI )" --> (855:241-855:257) " enableScopeAPI)" -(1423:257-1424:4) " {\n " --> (855:257-856:0) " {" -(1424:4-1424:11) " return" --> (856:0-856:11) "\n\t\t\t\treturn" -(1424:11-1425:3) " true;\n " --> (856:11-857:3) " true;\n\t\t" -(1425:3-1427:2) "}\n\n " --> (857:3-858:0) "\t}" -(1427:2-1427:13) " if (typeof" --> (858:0-858:14) "\n\t\t\tif (typeof" -(1427:13-1427:22) " type ===" --> (858:14-858:23) " type ===" -(1427:22-1427:34) " 'object' &&" --> (858:23-858:35) " \"object\" &&" -(1427:34-1427:43) " type !==" --> (858:35-858:44) " type !==" -(1427:43-1427:49) " null)" --> (858:44-858:50) " null)" -(1427:49-1428:4) " {\n " --> (858:50-859:0) " {" -(1428:4-1428:8) " if " --> (859:0-859:8) "\n\t\t\t\tif " -(1428:8-1428:13) "(type" --> (859:8-859:13) "(type" -(1428:13-1428:26) ".$$typeof ===" --> (859:13-859:26) ".$$typeof ===" -(1428:26-1428:45) " REACT_LAZY_TYPE ||" --> (859:26-859:45) " REACT_LAZY_TYPE ||" -(1428:45-1428:50) " type" --> (859:45-859:50) " type" -(1428:50-1428:63) ".$$typeof ===" --> (859:50-859:63) ".$$typeof ===" -(1428:63-1428:82) " REACT_MEMO_TYPE ||" --> (859:63-859:82) " REACT_MEMO_TYPE ||" -(1428:82-1428:87) " type" --> (859:82-859:87) " type" -(1428:87-1428:100) ".$$typeof ===" --> (859:87-859:100) ".$$typeof ===" -(1428:100-1428:123) " REACT_PROVIDER_TYPE ||" --> (859:100-859:123) " REACT_PROVIDER_TYPE ||" -(1428:123-1428:128) " type" --> (859:123-859:128) " type" -(1428:128-1428:141) ".$$typeof ===" --> (859:128-859:141) ".$$typeof ===" -(1428:141-1428:163) " REACT_CONTEXT_TYPE ||" --> (859:141-859:163) " REACT_CONTEXT_TYPE ||" -(1428:163-1428:168) " type" --> (859:163-859:168) " type" -(1428:168-1428:181) ".$$typeof ===" --> (859:168-859:181) ".$$typeof ===" -(1428:181-1428:207) " REACT_FORWARD_REF_TYPE ||" --> (859:181-859:207) " REACT_FORWARD_REF_TYPE ||" -(1428:207-1428:212) " type" --> (859:207-859:212) " type" -(1428:212-1428:225) ".$$typeof ===" --> (859:212-859:225) ".$$typeof ===" -(1428:225-1428:251) " REACT_FUNDAMENTAL_TYPE ||" --> (859:225-859:251) " REACT_FUNDAMENTAL_TYPE ||" -(1428:251-1428:256) " type" --> (859:251-859:256) " type" -(1428:256-1428:269) ".$$typeof ===" --> (859:256-859:269) ".$$typeof ===" -(1428:269-1428:289) " REACT_BLOCK_TYPE ||" --> (859:269-859:289) " REACT_BLOCK_TYPE ||" -(1428:289-1428:294) " type" --> (859:289-859:294) " type" -(1428:294-1428:301) "[0] ===" --> (859:294-859:301) "[0] ===" -(1428:301-1428:326) " REACT_SERVER_BLOCK_TYPE)" --> (859:301-859:326) " REACT_SERVER_BLOCK_TYPE)" -(1428:326-1429:6) " {\n " --> (859:326-860:0) " {" -(1429:6-1429:13) " return" --> (860:0-860:12) "\n\t\t\t\t\treturn" -(1429:13-1430:5) " true;\n " --> (860:12-861:4) " true;\n\t\t\t" -(1430:5-1431:3) "}\n " --> (861:4-862:3) "\t}\n\t\t" -(1431:3-1433:2) "}\n\n " --> (862:3-863:0) "\t}" -(1433:2-1433:9) " return" --> (863:0-863:10) "\n\t\t\treturn" -(1433:9-1434:1) " false;\n" --> (863:10-864:2) " false;\n\t" -(1434:1-1436:0) "}\n" --> (864:2-865:2) "\t}\n\t" -(1436:0-1436:9) "\nfunction" --> (865:2-865:11) "\tfunction" -(1436:9-1436:14) " memo" --> (865:11-865:16) " memo" -(1436:14-1436:20) "(type," --> (865:16-865:22) "(type," -(1436:20-1436:29) " compare)" --> (865:22-865:31) " compare)" -(1436:29-1437:2) " {\n " --> (865:31-866:3) " {\n\t\t" -(1437:2-1438:4) " {\n " --> (866:3-867:0) "\t{" -(1438:4-1438:9) " if (" --> (867:0-867:9) "\n\t\t\t\tif (" -(1438:9-1438:28) "!isValidElementType" --> (867:9-867:28) "!isValidElementType" -(1438:28-1438:33) "(type" --> (867:28-867:33) "(type" -(1438:33-1438:35) "))" --> (867:33-867:35) "))" -(1438:35-1439:6) " {\n " --> (867:35-868:0) " {" -(1439:6-1439:12) " error" --> (868:0-868:11) "\n\t\t\t\t\terror" -(1439:12-1439:71) "('memo: The first argument must be a component. Instead ' +" --> (868:11-868:70) "(\"memo: The first argument must be a component. Instead \" +" -(1439:71-1439:87) " 'received: %s'," --> (868:70-868:86) " \"received: %s\"," -(1439:87-1439:96) " type ===" --> (868:86-868:95) " type ===" -(1439:96-1439:103) " null ?" --> (868:95-868:102) " null ?" -(1439:103-1439:119) " 'null' : typeof" --> (868:102-868:118) " \"null\" : typeof" -(1439:119-1439:124) " type" --> (868:118-868:123) " type" -(1439:124-1440:5) ");\n " --> (868:123-869:4) ");\n\t\t\t" -(1440:5-1441:3) "}\n " --> (869:4-870:3) "\t}\n\t\t" -(1441:3-1443:2) "}\n\n " --> (870:3-871:3) "\t}\n\t\t" -(1443:2-1443:6) " var" --> (871:3-871:7) "\tvar" -(1443:6-1443:20) " elementType =" --> (871:7-871:21) " elementType =" -(1443:20-1444:4) " {\n " --> (871:21-872:4) " {\n\t\t\t" -(1444:4-1444:14) " $$typeof:" --> (872:4-872:14) "\t$$typeof:" -(1444:14-1445:10) " REACT_MEMO_TYPE,\n type:" --> (872:14-873:4) " REACT_MEMO_TYPE,\n\t\t\t" -(1445:10-1446:4) " type,\n " --> (873:4-874:4) "\ttype,\n\t\t\t" -(1446:4-1446:13) " compare:" --> (874:4-874:13) "\tcompare:" -(1446:13-1446:25) " compare ===" --> (874:13-874:25) " compare ===" -(1446:25-1446:37) " undefined ?" --> (874:25-874:37) " undefined ?" -(1446:37-1446:44) " null :" --> (874:37-874:44) " null :" -(1446:44-1447:3) " compare\n " --> (874:44-875:3) " compare\n\t\t" -(1447:3-1449:2) "};\n\n " --> (875:3-876:3) "\t};\n\t\t" -(1449:2-1450:4) " {\n " --> (876:3-877:4) "\t{\n\t\t\t" -(1450:4-1450:8) " var" --> (877:4-877:8) "\tvar" -(1450:8-1451:4) " ownName;\n " --> (877:8-878:0) " ownName;" -(1451:4-1451:11) " Object" --> (878:0-878:11) "\n\t\t\t\tObject" -(1451:11-1451:26) ".defineProperty" --> (878:11-878:26) ".defineProperty" -(1451:26-1451:39) "(elementType," --> (878:26-878:39) "(elementType," -(1451:39-1451:54) " 'displayName'," --> (878:39-878:54) " \"displayName\"," -(1451:54-1452:6) " {\n " --> (878:54-879:5) " {\n\t\t\t\t" -(1452:6-1452:18) " enumerable:" --> (879:5-879:17) "\tenumerable:" -(1452:18-1453:6) " false,\n " --> (879:17-880:5) " false,\n\t\t\t\t" -(1453:6-1453:20) " configurable:" --> (880:5-880:19) "\tconfigurable:" -(1453:20-1454:6) " true,\n " --> (880:19-881:5) " true,\n\t\t\t\t" -(1454:6-1454:11) " get:" --> (881:5-881:10) "\tget:" -(1454:11-1454:23) " function ()" --> (881:10-881:21) " function()" -(1454:23-1455:8) " {\n " --> (881:21-882:0) " {" -(1455:8-1455:15) " return" --> (882:0-882:13) "\n\t\t\t\t\t\treturn" -(1455:15-1456:7) " ownName;\n " --> (882:13-883:5) " ownName;\n\t\t\t\t" -(1456:7-1457:6) "},\n " --> (883:5-884:5) "\t},\n\t\t\t\t" -(1457:6-1457:11) " set:" --> (884:5-884:10) "\tset:" -(1457:11-1457:21) " function " --> (884:10-884:19) " function" -(1457:21-1457:27) "(name)" --> (884:19-884:25) "(name)" -(1457:27-1458:8) " {\n " --> (884:25-885:0) " {" -(1458:8-1458:18) " ownName =" --> (885:0-885:16) "\n\t\t\t\t\t\townName =" -(1458:18-1460:8) " name;\n\n " --> (885:16-886:0) " name;" -(1460:8-1460:12) " if " --> (886:0-886:10) "\n\t\t\t\t\t\tif " -(1460:12-1460:17) "(type" --> (886:10-886:15) "(type" -(1460:17-1460:32) ".displayName ==" --> (886:15-886:30) ".displayName ==" -(1460:32-1460:38) " null)" --> (886:30-886:36) " null)" -(1460:38-1461:10) " {\n " --> (886:36-887:0) " {" -(1461:10-1461:15) " type" --> (887:0-887:12) "\n\t\t\t\t\t\t\ttype" -(1461:15-1461:29) ".displayName =" --> (887:12-887:26) ".displayName =" -(1461:29-1462:9) " name;\n " --> (887:26-888:6) " name;\n\t\t\t\t\t" -(1462:9-1463:7) "}\n " --> (888:6-889:5) "\t}\n\t\t\t\t" -(1463:7-1464:5) "}\n " --> (889:5-890:4) "\t}\n\t\t\t" -(1464:5-1464:6) "}" --> (890:4-890:6) "\t}" -(1464:6-1465:3) ");\n " --> (890:6-891:3) ");\n\t\t" -(1465:3-1467:2) "}\n\n " --> (891:3-892:0) "\t}" -(1467:2-1467:9) " return" --> (892:0-892:10) "\n\t\t\treturn" -(1467:9-1468:1) " elementType;\n" --> (892:10-893:2) " elementType;\n\t" -(1468:1-1470:0) "}\n" --> (893:2-894:2) "\t}\n\t" -(1470:0-1470:9) "\nfunction" --> (894:2-894:11) "\tfunction" -(1470:9-1470:29) " resolveDispatcher()" --> (894:11-894:31) " resolveDispatcher()" -(1470:29-1471:2) " {\n " --> (894:31-895:3) " {\n\t\t" -(1471:2-1471:6) " var" --> (895:3-895:7) "\tvar" -(1471:6-1471:19) " dispatcher =" --> (895:7-895:20) " dispatcher =" -(1471:19-1471:42) " ReactCurrentDispatcher" --> (895:20-895:43) " ReactCurrentDispatcher" -(1471:42-1473:2) ".current;\n\n " --> (895:43-896:0) ".current;" -(1473:2-1473:8) " if (!" --> (896:0-896:9) "\n\t\t\tif (!" -(1473:8-1473:23) "(dispatcher !==" --> (896:9-896:24) "(dispatcher !==" -(1473:23-1473:30) " null))" --> (896:24-896:31) " null))" -(1473:30-1474:4) " {\n " --> (896:31-897:4) " {\n\t\t\t" -(1474:4-1475:6) " {\n " --> (897:4-898:0) "\t{" -(1475:6-1475:12) " throw" --> (898:0-898:11) "\n\t\t\t\t\tthrow" -(1475:12-1475:19) " Error(" --> (898:11-898:17) " Error" -(1475:19-1475:454) " \"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.\" " --> (898:17-898:451) "(\"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.\"" -(1475:454-1476:5) ");\n " --> (898:451-899:4) ");\n\t\t\t" -(1476:5-1477:3) "}\n " --> (899:4-900:3) "\t}\n\t\t" -(1477:3-1479:2) "}\n\n " --> (900:3-901:0) "\t}" -(1479:2-1479:9) " return" --> (901:0-901:10) "\n\t\t\treturn" -(1479:9-1480:1) " dispatcher;\n" --> (901:10-902:2) " dispatcher;\n\t" -(1480:1-1482:0) "}\n" --> (902:2-903:2) "\t}\n\t" -(1482:0-1482:9) "\nfunction" --> (903:2-903:11) "\tfunction" -(1482:9-1482:20) " useContext" --> (903:11-903:22) " useContext" -(1482:20-1482:29) "(Context," --> (903:22-903:31) "(Context," -(1482:29-1482:52) " unstable_observedBits)" --> (903:31-903:54) " unstable_observedBits)" -(1482:52-1483:2) " {\n " --> (903:54-904:3) " {\n\t\t" -(1483:2-1483:6) " var" --> (904:3-904:7) "\tvar" -(1483:6-1483:19) " dispatcher =" --> (904:7-904:20) " dispatcher =" -(1483:19-1483:38) " resolveDispatcher(" --> (904:20-904:39) " resolveDispatcher(" -(1483:38-1485:2) ");\n\n " --> (904:39-905:3) ");\n\t\t" -(1485:2-1486:4) " {\n " --> (905:3-906:0) "\t{" -(1486:4-1486:8) " if " --> (906:0-906:8) "\n\t\t\t\tif " -(1486:8-1486:34) "(unstable_observedBits !==" --> (906:8-906:34) "(unstable_observedBits !==" -(1486:34-1486:45) " undefined)" --> (906:34-906:45) " undefined)" -(1486:45-1487:6) " {\n " --> (906:45-907:0) " {" -(1487:6-1487:12) " error" --> (907:0-907:11) "\n\t\t\t\t\terror" -(1487:12-1487:69) "('useContext() second argument is reserved for future ' +" --> (907:11-907:68) "(\"useContext() second argument is reserved for future \" +" -(1487:69-1487:117) " 'use in React. Passing it is not supported. ' +" --> (907:68-907:116) " \"use in React. Passing it is not supported. \" +" -(1487:117-1487:138) " 'You passed: %s.%s'," --> (907:116-907:137) " \"You passed: %s.%s\"," -(1487:138-1487:168) " unstable_observedBits, typeof" --> (907:137-907:167) " unstable_observedBits, typeof" -(1487:168-1487:194) " unstable_observedBits ===" --> (907:167-907:193) " unstable_observedBits ===" -(1487:194-1487:206) " 'number' &&" --> (907:193-907:205) " \"number\" &&" -(1487:206-1487:212) " Array" --> (907:205-907:211) " Array" -(1487:212-1487:220) ".isArray" --> (907:211-907:219) ".isArray" -(1487:220-1487:230) "(arguments" --> (907:219-907:229) "(arguments" -(1487:230-1487:233) "[2]" --> (907:229-907:232) "[2]" -(1487:233-1487:236) ") ?" --> (907:232-907:235) ") ?" -(1487:236-1487:281) " '\\n\\nDid you call array.map(useContext)? ' +" --> (907:235-907:280) " \"\\n\\nDid you call array.map(useContext)? \" +" -(1487:281-1487:332) " 'Calling Hooks inside a loop is not supported. ' +" --> (907:280-907:331) " \"Calling Hooks inside a loop is not supported. \" +" -(1487:332-1487:390) " 'Learn more at https://reactjs.org/link/rules-of-hooks' :" --> (907:331-907:389) " \"Learn more at https://reactjs.org/link/rules-of-hooks\" :" -(1487:390-1487:393) " ''" --> (907:389-907:392) " \"\"" -(1487:393-1488:5) ");\n " --> (907:392-908:4) ");\n\t\t\t" -(1488:5-1491:4) "} // TODO: add a more generic warning for invalid values.\n\n\n " --> (908:4-909:0) "\t}" -(1491:4-1491:8) " if " --> (909:0-909:8) "\n\t\t\t\tif " -(1491:8-1491:16) "(Context" --> (909:8-909:16) "(Context" -(1491:16-1491:29) "._context !==" --> (909:16-909:29) "._context !==" -(1491:29-1491:40) " undefined)" --> (909:29-909:40) " undefined)" -(1491:40-1492:6) " {\n " --> (909:40-910:5) " {\n\t\t\t\t" -(1492:6-1492:10) " var" --> (910:5-910:9) "\tvar" -(1492:10-1492:24) " realContext =" --> (910:9-910:23) " realContext =" -(1492:24-1492:32) " Context" --> (910:23-910:31) " Context" -(1492:32-1495:6) "._context; // Don't deduplicate because this legitimately causes bugs\n // and nobody should be using this in existing code.\n\n " --> (910:31-911:0) "._context;" -(1495:6-1495:10) " if " --> (911:0-911:9) "\n\t\t\t\t\tif " -(1495:10-1495:22) "(realContext" --> (911:9-911:21) "(realContext" -(1495:22-1495:35) ".Consumer ===" --> (911:21-911:34) ".Consumer ===" -(1495:35-1495:44) " Context)" --> (911:34-911:43) " Context)" -(1495:44-1496:8) " {\n " --> (911:43-912:0) " {" -(1496:8-1496:14) " error" --> (912:0-912:12) "\n\t\t\t\t\t\terror" -(1496:14-1496:102) "('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' +" --> (912:12-912:100) "(\"Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be \" +" -(1496:102-1496:189) " 'removed in a future major release. Did you mean to call useContext(Context) instead?'" --> (912:100-912:187) " \"removed in a future major release. Did you mean to call useContext(Context) instead?\"" -(1496:189-1497:7) ");\n " --> (912:187-913:5) ");\n\t\t\t\t" -(1497:7-1497:17) "} else if " --> (913:5-913:16) "\t} else if " -(1497:17-1497:29) "(realContext" --> (913:16-913:28) "(realContext" -(1497:29-1497:42) ".Provider ===" --> (913:28-913:41) ".Provider ===" -(1497:42-1497:51) " Context)" --> (913:41-913:50) " Context)" -(1497:51-1498:8) " {\n " --> (913:50-914:0) " {" -(1498:8-1498:14) " error" --> (914:0-914:12) "\n\t\t\t\t\t\terror" -(1498:14-1498:74) "('Calling useContext(Context.Provider) is not supported. ' +" --> (914:12-914:72) "(\"Calling useContext(Context.Provider) is not supported. \" +" -(1498:74-1498:126) " 'Did you mean to call useContext(Context) instead?'" --> (914:72-914:124) " \"Did you mean to call useContext(Context) instead?\"" -(1498:126-1499:7) ");\n " --> (914:124-915:5) ");\n\t\t\t\t" -(1499:7-1500:5) "}\n " --> (915:5-916:4) "\t}\n\t\t\t" -(1500:5-1501:3) "}\n " --> (916:4-917:3) "\t}\n\t\t" -(1501:3-1503:2) "}\n\n " --> (917:3-918:0) "\t}" -(1503:2-1503:9) " return" --> (918:0-918:10) "\n\t\t\treturn" -(1503:9-1503:20) " dispatcher" --> (918:10-918:21) " dispatcher" -(1503:20-1503:31) ".useContext" --> (918:21-918:32) ".useContext" -(1503:31-1503:40) "(Context," --> (918:32-918:41) "(Context," -(1503:40-1503:62) " unstable_observedBits" --> (918:41-918:63) " unstable_observedBits" -(1503:62-1504:1) ");\n" --> (918:63-919:2) ");\n\t" -(1504:1-1505:0) "}" --> (919:2-920:2) "\t}\n\t" -(1505:0-1505:9) "\nfunction" --> (920:2-920:11) "\tfunction" -(1505:9-1505:18) " useState" --> (920:11-920:20) " useState" -(1505:18-1505:32) "(initialState)" --> (920:20-920:34) "(initialState)" -(1505:32-1506:2) " {\n " --> (920:34-921:3) " {\n\t\t" -(1506:2-1506:6) " var" --> (921:3-921:7) "\tvar" -(1506:6-1506:19) " dispatcher =" --> (921:7-921:20) " dispatcher =" -(1506:19-1506:38) " resolveDispatcher(" --> (921:20-921:39) " resolveDispatcher(" -(1506:38-1507:2) ");\n " --> (921:39-922:0) ");" -(1507:2-1507:9) " return" --> (922:0-922:10) "\n\t\t\treturn" -(1507:9-1507:20) " dispatcher" --> (922:10-922:21) " dispatcher" -(1507:20-1507:29) ".useState" --> (922:21-922:30) ".useState" -(1507:29-1507:42) "(initialState" --> (922:30-922:43) "(initialState" -(1507:42-1508:1) ");\n" --> (922:43-923:2) ");\n\t" -(1508:1-1509:0) "}" --> (923:2-924:2) "\t}\n\t" -(1509:0-1509:9) "\nfunction" --> (924:2-924:11) "\tfunction" -(1509:9-1509:20) " useReducer" --> (924:11-924:22) " useReducer" -(1509:20-1509:29) "(reducer," --> (924:22-924:31) "(reducer," -(1509:29-1509:41) " initialArg," --> (924:31-924:43) " initialArg," -(1509:41-1509:47) " init)" --> (924:43-924:49) " init)" -(1509:47-1510:2) " {\n " --> (924:49-925:3) " {\n\t\t" -(1510:2-1510:6) " var" --> (925:3-925:7) "\tvar" -(1510:6-1510:19) " dispatcher =" --> (925:7-925:20) " dispatcher =" -(1510:19-1510:38) " resolveDispatcher(" --> (925:20-925:39) " resolveDispatcher(" -(1510:38-1511:2) ");\n " --> (925:39-926:0) ");" -(1511:2-1511:9) " return" --> (926:0-926:10) "\n\t\t\treturn" -(1511:9-1511:20) " dispatcher" --> (926:10-926:21) " dispatcher" -(1511:20-1511:31) ".useReducer" --> (926:21-926:32) ".useReducer" -(1511:31-1511:40) "(reducer," --> (926:32-926:41) "(reducer," -(1511:40-1511:52) " initialArg," --> (926:41-926:53) " initialArg," -(1511:52-1511:57) " init" --> (926:53-926:58) " init" -(1511:57-1512:1) ");\n" --> (926:58-927:2) ");\n\t" -(1512:1-1513:0) "}" --> (927:2-928:2) "\t}\n\t" -(1513:0-1513:9) "\nfunction" --> (928:2-928:11) "\tfunction" -(1513:9-1513:16) " useRef" --> (928:11-928:18) " useRef" -(1513:16-1513:30) "(initialValue)" --> (928:18-928:32) "(initialValue)" -(1513:30-1514:2) " {\n " --> (928:32-929:3) " {\n\t\t" -(1514:2-1514:6) " var" --> (929:3-929:7) "\tvar" -(1514:6-1514:19) " dispatcher =" --> (929:7-929:20) " dispatcher =" -(1514:19-1514:38) " resolveDispatcher(" --> (929:20-929:39) " resolveDispatcher(" -(1514:38-1515:2) ");\n " --> (929:39-930:0) ");" -(1515:2-1515:9) " return" --> (930:0-930:10) "\n\t\t\treturn" -(1515:9-1515:20) " dispatcher" --> (930:10-930:21) " dispatcher" -(1515:20-1515:27) ".useRef" --> (930:21-930:28) ".useRef" -(1515:27-1515:40) "(initialValue" --> (930:28-930:41) "(initialValue" -(1515:40-1516:1) ");\n" --> (930:41-931:2) ");\n\t" -(1516:1-1517:0) "}" --> (931:2-932:2) "\t}\n\t" -(1517:0-1517:9) "\nfunction" --> (932:2-932:11) "\tfunction" -(1517:9-1517:19) " useEffect" --> (932:11-932:21) " useEffect" -(1517:19-1517:27) "(create," --> (932:21-932:29) "(create," -(1517:27-1517:33) " deps)" --> (932:29-932:35) " deps)" -(1517:33-1518:2) " {\n " --> (932:35-933:3) " {\n\t\t" -(1518:2-1518:6) " var" --> (933:3-933:7) "\tvar" -(1518:6-1518:19) " dispatcher =" --> (933:7-933:20) " dispatcher =" -(1518:19-1518:38) " resolveDispatcher(" --> (933:20-933:39) " resolveDispatcher(" -(1518:38-1519:2) ");\n " --> (933:39-934:0) ");" -(1519:2-1519:9) " return" --> (934:0-934:10) "\n\t\t\treturn" -(1519:9-1519:20) " dispatcher" --> (934:10-934:21) " dispatcher" -(1519:20-1519:30) ".useEffect" --> (934:21-934:31) ".useEffect" -(1519:30-1519:38) "(create," --> (934:31-934:39) "(create," -(1519:38-1519:43) " deps" --> (934:39-934:44) " deps" -(1519:43-1520:1) ");\n" --> (934:44-935:2) ");\n\t" -(1520:1-1521:0) "}" --> (935:2-936:2) "\t}\n\t" -(1521:0-1521:9) "\nfunction" --> (936:2-936:11) "\tfunction" -(1521:9-1521:25) " useLayoutEffect" --> (936:11-936:27) " useLayoutEffect" -(1521:25-1521:33) "(create," --> (936:27-936:35) "(create," -(1521:33-1521:39) " deps)" --> (936:35-936:41) " deps)" -(1521:39-1522:2) " {\n " --> (936:41-937:3) " {\n\t\t" -(1522:2-1522:6) " var" --> (937:3-937:7) "\tvar" -(1522:6-1522:19) " dispatcher =" --> (937:7-937:20) " dispatcher =" -(1522:19-1522:38) " resolveDispatcher(" --> (937:20-937:39) " resolveDispatcher(" -(1522:38-1523:2) ");\n " --> (937:39-938:0) ");" -(1523:2-1523:9) " return" --> (938:0-938:10) "\n\t\t\treturn" -(1523:9-1523:20) " dispatcher" --> (938:10-938:21) " dispatcher" -(1523:20-1523:36) ".useLayoutEffect" --> (938:21-938:37) ".useLayoutEffect" -(1523:36-1523:44) "(create," --> (938:37-938:45) "(create," -(1523:44-1523:49) " deps" --> (938:45-938:50) " deps" -(1523:49-1524:1) ");\n" --> (938:50-939:2) ");\n\t" -(1524:1-1525:0) "}" --> (939:2-940:2) "\t}\n\t" -(1525:0-1525:9) "\nfunction" --> (940:2-940:11) "\tfunction" -(1525:9-1525:21) " useCallback" --> (940:11-940:23) " useCallback" -(1525:21-1525:31) "(callback," --> (940:23-940:33) "(callback," -(1525:31-1525:37) " deps)" --> (940:33-940:39) " deps)" -(1525:37-1526:2) " {\n " --> (940:39-941:3) " {\n\t\t" -(1526:2-1526:6) " var" --> (941:3-941:7) "\tvar" -(1526:6-1526:19) " dispatcher =" --> (941:7-941:20) " dispatcher =" -(1526:19-1526:38) " resolveDispatcher(" --> (941:20-941:39) " resolveDispatcher(" -(1526:38-1527:2) ");\n " --> (941:39-942:0) ");" -(1527:2-1527:9) " return" --> (942:0-942:10) "\n\t\t\treturn" -(1527:9-1527:20) " dispatcher" --> (942:10-942:21) " dispatcher" -(1527:20-1527:32) ".useCallback" --> (942:21-942:33) ".useCallback" -(1527:32-1527:42) "(callback," --> (942:33-942:43) "(callback," -(1527:42-1527:47) " deps" --> (942:43-942:48) " deps" -(1527:47-1528:1) ");\n" --> (942:48-943:2) ");\n\t" -(1528:1-1529:0) "}" --> (943:2-944:2) "\t}\n\t" -(1529:0-1529:9) "\nfunction" --> (944:2-944:11) "\tfunction" -(1529:9-1529:17) " useMemo" --> (944:11-944:19) " useMemo" -(1529:17-1529:25) "(create," --> (944:19-944:27) "(create," -(1529:25-1529:31) " deps)" --> (944:27-944:33) " deps)" -(1529:31-1530:2) " {\n " --> (944:33-945:3) " {\n\t\t" -(1530:2-1530:6) " var" --> (945:3-945:7) "\tvar" -(1530:6-1530:19) " dispatcher =" --> (945:7-945:20) " dispatcher =" -(1530:19-1530:38) " resolveDispatcher(" --> (945:20-945:39) " resolveDispatcher(" -(1530:38-1531:2) ");\n " --> (945:39-946:0) ");" -(1531:2-1531:9) " return" --> (946:0-946:10) "\n\t\t\treturn" -(1531:9-1531:20) " dispatcher" --> (946:10-946:21) " dispatcher" -(1531:20-1531:28) ".useMemo" --> (946:21-946:29) ".useMemo" -(1531:28-1531:36) "(create," --> (946:29-946:37) "(create," -(1531:36-1531:41) " deps" --> (946:37-946:42) " deps" -(1531:41-1532:1) ");\n" --> (946:42-947:2) ");\n\t" -(1532:1-1533:0) "}" --> (947:2-948:2) "\t}\n\t" -(1533:0-1533:9) "\nfunction" --> (948:2-948:11) "\tfunction" -(1533:9-1533:29) " useImperativeHandle" --> (948:11-948:31) " useImperativeHandle" -(1533:29-1533:34) "(ref," --> (948:31-948:36) "(ref," -(1533:34-1533:42) " create," --> (948:36-948:44) " create," -(1533:42-1533:48) " deps)" --> (948:44-948:50) " deps)" -(1533:48-1534:2) " {\n " --> (948:50-949:3) " {\n\t\t" -(1534:2-1534:6) " var" --> (949:3-949:7) "\tvar" -(1534:6-1534:19) " dispatcher =" --> (949:7-949:20) " dispatcher =" -(1534:19-1534:38) " resolveDispatcher(" --> (949:20-949:39) " resolveDispatcher(" -(1534:38-1535:2) ");\n " --> (949:39-950:0) ");" -(1535:2-1535:9) " return" --> (950:0-950:10) "\n\t\t\treturn" -(1535:9-1535:20) " dispatcher" --> (950:10-950:21) " dispatcher" -(1535:20-1535:40) ".useImperativeHandle" --> (950:21-950:41) ".useImperativeHandle" -(1535:40-1535:45) "(ref," --> (950:41-950:46) "(ref," -(1535:45-1535:53) " create," --> (950:46-950:54) " create," -(1535:53-1535:58) " deps" --> (950:54-950:59) " deps" -(1535:58-1536:1) ");\n" --> (950:59-951:2) ");\n\t" -(1536:1-1537:0) "}" --> (951:2-952:2) "\t}\n\t" -(1537:0-1537:9) "\nfunction" --> (952:2-952:11) "\tfunction" -(1537:9-1537:23) " useDebugValue" --> (952:11-952:25) " useDebugValue" -(1537:23-1537:30) "(value," --> (952:25-952:32) "(value," -(1537:30-1537:43) " formatterFn)" --> (952:32-952:45) " formatterFn)" -(1537:43-1538:2) " {\n " --> (952:45-953:3) " {\n\t\t" -(1538:2-1539:4) " {\n " --> (953:3-954:4) "\t{\n\t\t\t" -(1539:4-1539:8) " var" --> (954:4-954:8) "\tvar" -(1539:8-1539:21) " dispatcher =" --> (954:8-954:21) " dispatcher =" -(1539:21-1539:40) " resolveDispatcher(" --> (954:21-954:40) " resolveDispatcher(" -(1539:40-1540:4) ");\n " --> (954:40-955:0) ");" -(1540:4-1540:11) " return" --> (955:0-955:11) "\n\t\t\t\treturn" -(1540:11-1540:22) " dispatcher" --> (955:11-955:22) " dispatcher" -(1540:22-1540:36) ".useDebugValue" --> (955:22-955:36) ".useDebugValue" -(1540:36-1540:43) "(value," --> (955:36-955:43) "(value," -(1540:43-1540:55) " formatterFn" --> (955:43-955:55) " formatterFn" -(1540:55-1541:3) ");\n " --> (955:55-956:3) ");\n\t\t" -(1541:3-1542:1) "}\n" --> (956:3-957:2) "\t}\n\t" -(1542:1-1548:0) "}\n\n// Helpers to patch console.logs to avoid logging during side-effect free\n// replaying on render function. This currently only patches the object\n// lazily which won't cover if the log function was extracted eagerly.\n// We could also eagerly patch the method." --> (957:2-958:2) "\t}\n\t" -(1548:0-1548:4) "\nvar" --> (958:2-958:6) "\tvar" -(1548:4-1548:20) " disabledDepth =" --> (958:6-958:22) " disabledDepth =" -(1548:20-1549:0) " 0;" --> (958:22-959:2) " 0;\n\t" -(1549:0-1549:4) "\nvar" --> (959:2-959:6) "\tvar" -(1549:4-1550:0) " prevLog;" --> (959:6-960:2) " prevLog;\n\t" -(1550:0-1550:4) "\nvar" --> (960:2-960:6) "\tvar" -(1550:4-1551:0) " prevInfo;" --> (960:6-961:2) " prevInfo;\n\t" -(1551:0-1551:4) "\nvar" --> (961:2-961:6) "\tvar" -(1551:4-1552:0) " prevWarn;" --> (961:6-962:2) " prevWarn;\n\t" -(1552:0-1552:4) "\nvar" --> (962:2-962:6) "\tvar" -(1552:4-1553:0) " prevError;" --> (962:6-963:2) " prevError;\n\t" -(1553:0-1553:4) "\nvar" --> (963:2-963:6) "\tvar" -(1553:4-1554:0) " prevGroup;" --> (963:6-964:2) " prevGroup;\n\t" -(1554:0-1554:4) "\nvar" --> (964:2-964:6) "\tvar" -(1554:4-1555:0) " prevGroupCollapsed;" --> (964:6-965:2) " prevGroupCollapsed;\n\t" -(1555:0-1555:4) "\nvar" --> (965:2-965:6) "\tvar" -(1555:4-1557:0) " prevGroupEnd;\n" --> (965:6-966:2) " prevGroupEnd;\n\t" -(1557:0-1557:9) "\nfunction" --> (966:2-966:11) "\tfunction" -(1557:9-1557:23) " disabledLog()" --> (966:11-966:25) " disabledLog()" -(1557:23-1557:25) " {" --> (966:25-966:26) " " -(1557:25-1559:0) "}\n" --> (966:26-967:0) "{}" -(1559:0-1559:12) "\ndisabledLog" --> (967:0-967:14) "\n\t\tdisabledLog" -(1559:12-1559:33) ".__reactDisabledLog =" --> (967:14-967:35) ".__reactDisabledLog =" -(1559:33-1560:0) " true;" --> (967:35-968:2) " true;\n\t" -(1560:0-1560:9) "\nfunction" --> (968:2-968:11) "\tfunction" -(1560:9-1560:23) " disableLogs()" --> (968:11-968:25) " disableLogs()" -(1560:23-1561:2) " {\n " --> (968:25-969:3) " {\n\t\t" -(1561:2-1562:4) " {\n " --> (969:3-970:0) "\t{" -(1562:4-1562:8) " if " --> (970:0-970:8) "\n\t\t\t\tif " -(1562:8-1562:26) "(disabledDepth ===" --> (970:8-970:26) "(disabledDepth ===" -(1562:26-1562:29) " 0)" --> (970:26-970:29) " 0)" -(1562:29-1564:6) " {\n /* eslint-disable react-internal/no-production-logging */\n " --> (970:29-971:0) " {" -(1564:6-1564:16) " prevLog =" --> (971:0-971:15) "\n\t\t\t\t\tprevLog =" -(1564:16-1564:24) " console" --> (971:15-971:23) " console" -(1564:24-1565:6) ".log;\n " --> (971:23-972:0) ".log;" -(1565:6-1565:17) " prevInfo =" --> (972:0-972:16) "\n\t\t\t\t\tprevInfo =" -(1565:17-1565:25) " console" --> (972:16-972:24) " console" -(1565:25-1566:6) ".info;\n " --> (972:24-973:0) ".info;" -(1566:6-1566:17) " prevWarn =" --> (973:0-973:16) "\n\t\t\t\t\tprevWarn =" -(1566:17-1566:25) " console" --> (973:16-973:24) " console" -(1566:25-1567:6) ".warn;\n " --> (973:24-974:0) ".warn;" -(1567:6-1567:18) " prevError =" --> (974:0-974:17) "\n\t\t\t\t\tprevError =" -(1567:18-1567:26) " console" --> (974:17-974:25) " console" -(1567:26-1568:6) ".error;\n " --> (974:25-975:0) ".error;" -(1568:6-1568:18) " prevGroup =" --> (975:0-975:17) "\n\t\t\t\t\tprevGroup =" -(1568:18-1568:26) " console" --> (975:17-975:25) " console" -(1568:26-1569:6) ".group;\n " --> (975:25-976:0) ".group;" -(1569:6-1569:27) " prevGroupCollapsed =" --> (976:0-976:26) "\n\t\t\t\t\tprevGroupCollapsed =" -(1569:27-1569:35) " console" --> (976:26-976:34) " console" -(1569:35-1570:6) ".groupCollapsed;\n " --> (976:34-977:0) ".groupCollapsed;" -(1570:6-1570:21) " prevGroupEnd =" --> (977:0-977:20) "\n\t\t\t\t\tprevGroupEnd =" -(1570:21-1570:29) " console" --> (977:20-977:28) " console" -(1570:29-1572:6) ".groupEnd; // https://github.com/facebook/react/issues/19099\n\n " --> (977:28-978:5) ".groupEnd;\n\t\t\t\t" -(1572:6-1572:10) " var" --> (978:5-978:9) "\tvar" -(1572:10-1572:18) " props =" --> (978:9-978:17) " props =" -(1572:18-1573:8) " {\n " --> (978:17-979:6) " {\n\t\t\t\t\t" -(1573:8-1573:22) " configurable:" --> (979:6-979:20) "\tconfigurable:" -(1573:22-1574:8) " true,\n " --> (979:20-980:6) " true,\n\t\t\t\t\t" -(1574:8-1574:20) " enumerable:" --> (980:6-980:18) "\tenumerable:" -(1574:20-1575:8) " true,\n " --> (980:18-981:6) " true,\n\t\t\t\t\t" -(1575:8-1575:15) " value:" --> (981:6-981:13) "\tvalue:" -(1575:15-1576:8) " disabledLog,\n " --> (981:13-982:6) " disabledLog,\n\t\t\t\t\t" -(1576:8-1576:18) " writable:" --> (982:6-982:16) "\twritable:" -(1576:18-1577:7) " true\n " --> (982:16-983:5) " true\n\t\t\t\t" -(1577:7-1579:6) "}; // $FlowFixMe Flow thinks console is immutable.\n\n " --> (983:5-984:0) "\t};" -(1579:6-1579:13) " Object" --> (984:0-984:12) "\n\t\t\t\t\tObject" -(1579:13-1579:30) ".defineProperties" --> (984:12-984:29) ".defineProperties" -(1579:30-1579:39) "(console," --> (984:29-984:38) "(console," -(1579:39-1580:8) " {\n " --> (984:38-985:6) " {\n\t\t\t\t\t" -(1580:8-1580:14) " info:" --> (985:6-985:12) "\tinfo:" -(1580:14-1581:8) " props,\n " --> (985:12-986:6) " props,\n\t\t\t\t\t" -(1581:8-1581:13) " log:" --> (986:6-986:11) "\tlog:" -(1581:13-1582:8) " props,\n " --> (986:11-987:6) " props,\n\t\t\t\t\t" -(1582:8-1582:14) " warn:" --> (987:6-987:12) "\twarn:" -(1582:14-1583:8) " props,\n " --> (987:12-988:6) " props,\n\t\t\t\t\t" -(1583:8-1583:15) " error:" --> (988:6-988:13) "\terror:" -(1583:15-1584:8) " props,\n " --> (988:13-989:6) " props,\n\t\t\t\t\t" -(1584:8-1584:15) " group:" --> (989:6-989:13) "\tgroup:" -(1584:15-1585:8) " props,\n " --> (989:13-990:6) " props,\n\t\t\t\t\t" -(1585:8-1585:24) " groupCollapsed:" --> (990:6-990:22) "\tgroupCollapsed:" -(1585:24-1586:8) " props,\n " --> (990:22-991:6) " props,\n\t\t\t\t\t" -(1586:8-1586:18) " groupEnd:" --> (991:6-991:16) "\tgroupEnd:" -(1586:18-1587:7) " props\n " --> (991:16-992:5) " props\n\t\t\t\t" -(1587:7-1587:8) "}" --> (992:5-992:7) "\t}" -(1587:8-1589:5) ");\n /* eslint-enable react-internal/no-production-logging */\n " --> (992:7-993:4) ");\n\t\t\t" -(1589:5-1591:4) "}\n\n " --> (993:4-994:0) "\t}" -(1591:4-1592:3) " disabledDepth++;\n " --> (994:0-995:3) "\n\t\t\t\tdisabledDepth++;\n\t\t" -(1592:3-1593:1) "}\n" --> (995:3-996:2) "\t}\n\t" -(1593:1-1594:0) "}" --> (996:2-997:2) "\t}\n\t" -(1594:0-1594:9) "\nfunction" --> (997:2-997:11) "\tfunction" -(1594:9-1594:24) " reenableLogs()" --> (997:11-997:26) " reenableLogs()" -(1594:24-1595:2) " {\n " --> (997:26-998:3) " {\n\t\t" -(1595:2-1596:4) " {\n " --> (998:3-999:0) "\t{" -(1596:4-1598:4) " disabledDepth--;\n\n " --> (999:0-1000:0) "\n\t\t\t\tdisabledDepth--;" -(1598:4-1598:8) " if " --> (1000:0-1000:8) "\n\t\t\t\tif " -(1598:8-1598:26) "(disabledDepth ===" --> (1000:8-1000:26) "(disabledDepth ===" -(1598:26-1598:29) " 0)" --> (1000:26-1000:29) " 0)" -(1598:29-1600:6) " {\n /* eslint-disable react-internal/no-production-logging */\n " --> (1000:29-1001:5) " {\n\t\t\t\t" -(1600:6-1600:10) " var" --> (1001:5-1001:9) "\tvar" -(1600:10-1600:18) " props =" --> (1001:9-1001:17) " props =" -(1600:18-1601:8) " {\n " --> (1001:17-1002:6) " {\n\t\t\t\t\t" -(1601:8-1601:22) " configurable:" --> (1002:6-1002:20) "\tconfigurable:" -(1601:22-1602:8) " true,\n " --> (1002:20-1003:6) " true,\n\t\t\t\t\t" -(1602:8-1602:20) " enumerable:" --> (1003:6-1003:18) "\tenumerable:" -(1602:20-1603:8) " true,\n " --> (1003:18-1004:6) " true,\n\t\t\t\t\t" -(1603:8-1603:18) " writable:" --> (1004:6-1004:16) "\twritable:" -(1603:18-1604:7) " true\n " --> (1004:16-1005:5) " true\n\t\t\t\t" -(1604:7-1606:6) "}; // $FlowFixMe Flow thinks console is immutable.\n\n " --> (1005:5-1006:0) "\t};" -(1606:6-1606:13) " Object" --> (1006:0-1006:12) "\n\t\t\t\t\tObject" -(1606:13-1606:30) ".defineProperties" --> (1006:12-1006:29) ".defineProperties" -(1606:30-1606:39) "(console," --> (1006:29-1006:38) "(console," -(1606:39-1607:8) " {\n " --> (1006:38-1007:6) " {\n\t\t\t\t\t" -(1607:8-1607:13) " log:" --> (1007:6-1007:11) "\tlog:" -(1607:13-1607:21) " _assign" --> (1007:11-1007:19) " _assign" -(1607:21-1607:23) "({" --> (1007:19-1007:20) "(" -(1607:23-1607:25) "}," --> (1007:20-1007:23) "{}," -(1607:25-1607:32) " props," --> (1007:23-1007:30) " props," -(1607:32-1608:10) " {\n " --> (1007:30-1007:32) " {" -(1608:10-1608:17) " value:" --> (1007:32-1007:39) " value:" -(1608:17-1609:9) " prevLog\n " --> (1007:39-1007:47) " prevLog" -(1609:9-1609:10) "}" --> (1007:47-1007:49) " }" -(1609:10-1610:8) "),\n " --> (1007:49-1008:6) "),\n\t\t\t\t\t" -(1610:8-1610:14) " info:" --> (1008:6-1008:12) "\tinfo:" -(1610:14-1610:22) " _assign" --> (1008:12-1008:20) " _assign" -(1610:22-1610:24) "({" --> (1008:20-1008:21) "(" -(1610:24-1610:26) "}," --> (1008:21-1008:24) "{}," -(1610:26-1610:33) " props," --> (1008:24-1008:31) " props," -(1610:33-1611:10) " {\n " --> (1008:31-1008:33) " {" -(1611:10-1611:17) " value:" --> (1008:33-1008:40) " value:" -(1611:17-1612:9) " prevInfo\n " --> (1008:40-1008:49) " prevInfo" -(1612:9-1612:10) "}" --> (1008:49-1008:51) " }" -(1612:10-1613:8) "),\n " --> (1008:51-1009:6) "),\n\t\t\t\t\t" -(1613:8-1613:14) " warn:" --> (1009:6-1009:12) "\twarn:" -(1613:14-1613:22) " _assign" --> (1009:12-1009:20) " _assign" -(1613:22-1613:24) "({" --> (1009:20-1009:21) "(" -(1613:24-1613:26) "}," --> (1009:21-1009:24) "{}," -(1613:26-1613:33) " props," --> (1009:24-1009:31) " props," -(1613:33-1614:10) " {\n " --> (1009:31-1009:33) " {" -(1614:10-1614:17) " value:" --> (1009:33-1009:40) " value:" -(1614:17-1615:9) " prevWarn\n " --> (1009:40-1009:49) " prevWarn" -(1615:9-1615:10) "}" --> (1009:49-1009:51) " }" -(1615:10-1616:8) "),\n " --> (1009:51-1010:6) "),\n\t\t\t\t\t" -(1616:8-1616:15) " error:" --> (1010:6-1010:13) "\terror:" -(1616:15-1616:23) " _assign" --> (1010:13-1010:21) " _assign" -(1616:23-1616:25) "({" --> (1010:21-1010:22) "(" -(1616:25-1616:27) "}," --> (1010:22-1010:25) "{}," -(1616:27-1616:34) " props," --> (1010:25-1010:32) " props," -(1616:34-1617:10) " {\n " --> (1010:32-1010:34) " {" -(1617:10-1617:17) " value:" --> (1010:34-1010:41) " value:" -(1617:17-1618:9) " prevError\n " --> (1010:41-1010:51) " prevError" -(1618:9-1618:10) "}" --> (1010:51-1010:53) " }" -(1618:10-1619:8) "),\n " --> (1010:53-1011:6) "),\n\t\t\t\t\t" -(1619:8-1619:15) " group:" --> (1011:6-1011:13) "\tgroup:" -(1619:15-1619:23) " _assign" --> (1011:13-1011:21) " _assign" -(1619:23-1619:25) "({" --> (1011:21-1011:22) "(" -(1619:25-1619:27) "}," --> (1011:22-1011:25) "{}," -(1619:27-1619:34) " props," --> (1011:25-1011:32) " props," -(1619:34-1620:10) " {\n " --> (1011:32-1011:34) " {" -(1620:10-1620:17) " value:" --> (1011:34-1011:41) " value:" -(1620:17-1621:9) " prevGroup\n " --> (1011:41-1011:51) " prevGroup" -(1621:9-1621:10) "}" --> (1011:51-1011:53) " }" -(1621:10-1622:8) "),\n " --> (1011:53-1012:6) "),\n\t\t\t\t\t" -(1622:8-1622:24) " groupCollapsed:" --> (1012:6-1012:22) "\tgroupCollapsed:" -(1622:24-1622:32) " _assign" --> (1012:22-1012:30) " _assign" -(1622:32-1622:34) "({" --> (1012:30-1012:31) "(" -(1622:34-1622:36) "}," --> (1012:31-1012:34) "{}," -(1622:36-1622:43) " props," --> (1012:34-1012:41) " props," -(1622:43-1623:10) " {\n " --> (1012:41-1012:43) " {" -(1623:10-1623:17) " value:" --> (1012:43-1012:50) " value:" -(1623:17-1624:9) " prevGroupCollapsed\n " --> (1012:50-1012:69) " prevGroupCollapsed" -(1624:9-1624:10) "}" --> (1012:69-1012:71) " }" -(1624:10-1625:8) "),\n " --> (1012:71-1013:6) "),\n\t\t\t\t\t" -(1625:8-1625:18) " groupEnd:" --> (1013:6-1013:16) "\tgroupEnd:" -(1625:18-1625:26) " _assign" --> (1013:16-1013:24) " _assign" -(1625:26-1625:28) "({" --> (1013:24-1013:25) "(" -(1625:28-1625:30) "}," --> (1013:25-1013:28) "{}," -(1625:30-1625:37) " props," --> (1013:28-1013:35) " props," -(1625:37-1626:10) " {\n " --> (1013:35-1013:37) " {" -(1626:10-1626:17) " value:" --> (1013:37-1013:44) " value:" -(1626:17-1627:9) " prevGroupEnd\n " --> (1013:44-1013:57) " prevGroupEnd" -(1627:9-1627:10) "}" --> (1013:57-1013:59) " }" -(1627:10-1628:7) ")\n " --> (1013:59-1014:5) ")\n\t\t\t\t" -(1628:7-1628:8) "}" --> (1014:5-1014:7) "\t}" -(1628:8-1630:5) ");\n /* eslint-enable react-internal/no-production-logging */\n " --> (1014:7-1015:4) ");\n\t\t\t" -(1630:5-1632:4) "}\n\n " --> (1015:4-1016:0) "\t}" -(1632:4-1632:8) " if " --> (1016:0-1016:8) "\n\t\t\t\tif " -(1632:8-1632:24) "(disabledDepth <" --> (1016:8-1016:24) "(disabledDepth <" -(1632:24-1632:27) " 0)" --> (1016:24-1016:27) " 0)" -(1632:27-1633:6) " {\n " --> (1016:27-1017:0) " {" -(1633:6-1633:12) " error" --> (1017:0-1017:11) "\n\t\t\t\t\terror" -(1633:12-1633:48) "('disabledDepth fell below zero. ' +" --> (1017:11-1017:47) "(\"disabledDepth fell below zero. \" +" -(1633:48-1633:96) " 'This is a bug in React. Please file an issue.'" --> (1017:47-1017:95) " \"This is a bug in React. Please file an issue.\"" -(1633:96-1634:5) ");\n " --> (1017:95-1018:4) ");\n\t\t\t" -(1634:5-1635:3) "}\n " --> (1018:4-1019:3) "\t}\n\t\t" -(1635:3-1636:1) "}\n" --> (1019:3-1020:2) "\t}\n\t" -(1636:1-1638:0) "}\n" --> (1020:2-1021:2) "\t}\n\t" -(1638:0-1638:4) "\nvar" --> (1021:2-1021:6) "\tvar" -(1638:4-1638:31) " ReactCurrentDispatcher$1 =" --> (1021:6-1021:33) " ReactCurrentDispatcher$1 =" -(1638:31-1638:52) " ReactSharedInternals" --> (1021:33-1021:54) " ReactSharedInternals" -(1638:52-1639:0) ".ReactCurrentDispatcher;" --> (1021:54-1022:2) ".ReactCurrentDispatcher;\n\t" -(1639:0-1639:4) "\nvar" --> (1022:2-1022:6) "\tvar" -(1639:4-1640:0) " prefix;" --> (1022:6-1023:2) " prefix;\n\t" -(1640:0-1640:9) "\nfunction" --> (1023:2-1023:11) "\tfunction" -(1640:9-1640:39) " describeBuiltInComponentFrame" --> (1023:11-1023:41) " describeBuiltInComponentFrame" -(1640:39-1640:45) "(name," --> (1023:41-1023:47) "(name," -(1640:45-1640:53) " source," --> (1023:47-1023:55) " source," -(1640:53-1640:62) " ownerFn)" --> (1023:55-1023:64) " ownerFn)" -(1640:62-1641:2) " {\n " --> (1023:64-1024:3) " {\n\t\t" -(1641:2-1642:4) " {\n " --> (1024:3-1025:0) "\t{" -(1642:4-1642:8) " if " --> (1025:0-1025:8) "\n\t\t\t\tif " -(1642:8-1642:19) "(prefix ===" --> (1025:8-1025:19) "(prefix ===" -(1642:19-1642:30) " undefined)" --> (1025:19-1025:30) " undefined)" -(1642:30-1644:6) " {\n // Extract the VM specific prefix used by each line.\n " --> (1025:30-1026:0) " {" -(1644:6-1644:10) " try" --> (1026:0-1026:9) "\n\t\t\t\t\ttry" -(1644:10-1645:8) " {\n " --> (1026:9-1027:0) " {" -(1645:8-1645:14) " throw" --> (1027:0-1027:12) "\n\t\t\t\t\t\tthrow" -(1645:14-1645:21) " Error(" --> (1027:12-1027:19) " Error(" -(1645:21-1646:7) ");\n " --> (1027:19-1028:5) ");\n\t\t\t\t" -(1646:7-1646:15) "} catch " --> (1028:5-1028:14) "\t} catch " -(1646:15-1646:18) "(x)" --> (1028:14-1028:17) "(x)" -(1646:18-1647:8) " {\n " --> (1028:17-1029:6) " {\n\t\t\t\t\t" -(1647:8-1647:12) " var" --> (1029:6-1029:10) "\tvar" -(1647:12-1647:20) " match =" --> (1029:10-1029:18) " match =" -(1647:20-1647:22) " x" --> (1029:18-1029:20) " x" -(1647:22-1647:28) ".stack" --> (1029:20-1029:26) ".stack" -(1647:28-1647:34) ".trim(" --> (1029:26-1029:32) ".trim(" -(1647:34-1647:35) ")" --> (1029:32-1029:33) ")" -(1647:35-1647:41) ".match" --> (1029:33-1029:39) ".match" -(1647:41-1647:56) "(/\\n( *(at )?)/" --> (1029:39-1029:54) "(/\\n( *(at )?)/" -(1647:56-1648:8) ");\n " --> (1029:54-1030:0) ");" -(1648:8-1648:17) " prefix =" --> (1030:0-1030:15) "\n\t\t\t\t\t\tprefix =" -(1648:17-1648:26) " match &&" --> (1030:15-1030:24) " match &&" -(1648:26-1648:32) " match" --> (1030:24-1030:30) " match" -(1648:32-1648:38) "[1] ||" --> (1030:30-1030:36) "[1] ||" -(1648:38-1649:7) " '';\n " --> (1030:36-1031:5) " \"\";\n\t\t\t\t" -(1649:7-1650:5) "}\n " --> (1031:5-1032:4) "\t}\n\t\t\t" -(1650:5-1653:4) "} // We use the prefix to ensure our stacks line up with native stack frames.\n\n\n " --> (1032:4-1033:0) "\t}" -(1653:4-1653:11) " return" --> (1033:0-1033:11) "\n\t\t\t\treturn" -(1653:11-1653:18) " '\\n' +" --> (1033:11-1033:18) " \"\\n\" +" -(1653:18-1653:27) " prefix +" --> (1033:18-1033:27) " prefix +" -(1653:27-1654:3) " name;\n " --> (1033:27-1034:3) " name;\n\t\t" -(1654:3-1655:1) "}\n" --> (1034:3-1035:2) "\t}\n\t" -(1655:1-1656:0) "}" --> (1035:2-1036:2) "\t}\n\t" -(1656:0-1656:4) "\nvar" --> (1036:2-1036:6) "\tvar" -(1656:4-1656:14) " reentry =" --> (1036:6-1036:16) " reentry =" -(1656:14-1657:0) " false;" --> (1036:16-1037:2) " false;\n\t" -(1657:0-1657:4) "\nvar" --> (1037:2-1037:6) "\tvar" -(1657:4-1659:0) " componentFrameCache;\n" --> (1037:6-1038:2) " componentFrameCache;\n\t" -(1659:0-1660:2) "\n{\n " --> (1038:2-1039:3) "\t{\n\t\t" -(1660:2-1660:6) " var" --> (1039:3-1039:7) "\tvar" -(1660:6-1660:31) " PossiblyWeakMap = typeof" --> (1039:7-1039:32) " PossiblyWeakMap = typeof" -(1660:31-1660:43) " WeakMap ===" --> (1039:32-1039:44) " WeakMap ===" -(1660:43-1660:56) " 'function' ?" --> (1039:44-1039:57) " \"function\" ?" -(1660:56-1660:66) " WeakMap :" --> (1039:57-1039:67) " WeakMap :" -(1660:66-1661:2) " Map;\n " --> (1039:67-1040:0) " Map;" -(1661:2-1661:24) " componentFrameCache =" --> (1040:0-1040:25) "\n\t\t\tcomponentFrameCache =" -(1661:24-1661:28) " new" --> (1040:25-1040:29) " new" -(1661:28-1662:1) " PossiblyWeakMap();\n" --> (1040:29-1041:2) " PossiblyWeakMap();\n\t" -(1662:1-1664:0) "}\n" --> (1041:2-1042:2) "\t}\n\t" -(1664:0-1664:9) "\nfunction" --> (1042:2-1042:11) "\tfunction" -(1664:9-1664:38) " describeNativeComponentFrame" --> (1042:11-1042:40) " describeNativeComponentFrame" -(1664:38-1664:42) "(fn," --> (1042:40-1042:44) "(fn," -(1664:42-1664:53) " construct)" --> (1042:44-1042:55) " construct)" -(1664:53-1666:2) " {\n // If something asked for a stack inside a fake render, it should get ignored.\n " --> (1042:55-1043:0) " {" -(1666:2-1666:7) " if (" --> (1043:0-1043:8) "\n\t\t\tif (" -(1666:7-1666:13) "!fn ||" --> (1043:8-1043:14) "!fn ||" -(1666:13-1666:22) " reentry)" --> (1043:14-1043:23) " reentry)" -(1666:22-1667:4) " {\n " --> (1043:23-1044:0) " {" -(1667:4-1667:11) " return" --> (1044:0-1044:11) "\n\t\t\t\treturn" -(1667:11-1668:3) " '';\n " --> (1044:11-1045:3) " \"\";\n\t\t" -(1668:3-1670:2) "}\n\n " --> (1045:3-1046:3) "\t}\n\t\t" -(1670:2-1671:4) " {\n " --> (1046:3-1047:4) "\t{\n\t\t\t" -(1671:4-1671:8) " var" --> (1047:4-1047:8) "\tvar" -(1671:8-1671:16) " frame =" --> (1047:8-1047:16) " frame =" -(1671:16-1671:36) " componentFrameCache" --> (1047:16-1047:36) " componentFrameCache" -(1671:36-1671:40) ".get" --> (1047:36-1047:40) ".get" -(1671:40-1671:43) "(fn" --> (1047:40-1047:43) "(fn" -(1671:43-1673:4) ");\n\n " --> (1047:43-1048:0) ");" -(1673:4-1673:8) " if " --> (1048:0-1048:8) "\n\t\t\t\tif " -(1673:8-1673:18) "(frame !==" --> (1048:8-1048:18) "(frame !==" -(1673:18-1673:29) " undefined)" --> (1048:18-1048:29) " undefined)" -(1673:29-1674:6) " {\n " --> (1048:29-1049:0) " {" -(1674:6-1674:13) " return" --> (1049:0-1049:12) "\n\t\t\t\t\treturn" -(1674:13-1675:5) " frame;\n " --> (1049:12-1050:4) " frame;\n\t\t\t" -(1675:5-1676:3) "}\n " --> (1050:4-1051:3) "\t}\n\t\t" -(1676:3-1678:2) "}\n\n " --> (1051:3-1052:3) "\t}\n\t\t" -(1678:2-1678:6) " var" --> (1052:3-1052:7) "\tvar" -(1678:6-1679:2) " control;\n " --> (1052:7-1053:0) " control;" -(1679:2-1679:12) " reentry =" --> (1053:0-1053:13) "\n\t\t\treentry =" -(1679:12-1680:2) " true;\n " --> (1053:13-1054:3) " true;\n\t\t" -(1680:2-1680:6) " var" --> (1054:3-1054:7) "\tvar" -(1680:6-1680:34) " previousPrepareStackTrace =" --> (1054:7-1054:35) " previousPrepareStackTrace =" -(1680:34-1680:40) " Error" --> (1054:35-1054:41) " Error" -(1680:40-1682:2) ".prepareStackTrace; // $FlowFixMe It does accept undefined.\n\n " --> (1054:41-1055:0) ".prepareStackTrace;" -(1682:2-1682:8) " Error" --> (1055:0-1055:9) "\n\t\t\tError" -(1682:8-1682:28) ".prepareStackTrace =" --> (1055:9-1055:29) ".prepareStackTrace =" -(1682:28-1683:2) " undefined;\n " --> (1055:29-1056:3) " undefined;\n\t\t" -(1683:2-1683:6) " var" --> (1056:3-1056:7) "\tvar" -(1683:6-1685:2) " previousDispatcher;\n\n " --> (1056:7-1057:3) " previousDispatcher;\n\t\t" -(1685:2-1686:4) " {\n " --> (1057:3-1058:0) "\t{" -(1686:4-1686:25) " previousDispatcher =" --> (1058:0-1058:25) "\n\t\t\t\tpreviousDispatcher =" -(1686:25-1686:50) " ReactCurrentDispatcher$1" --> (1058:25-1058:50) " ReactCurrentDispatcher$1" -(1686:50-1689:4) ".current; // Set the dispatcher in DEV because this might be call in the render function\n // for warnings.\n\n " --> (1058:50-1059:0) ".current;" -(1689:4-1689:29) " ReactCurrentDispatcher$1" --> (1059:0-1059:29) "\n\t\t\t\tReactCurrentDispatcher$1" -(1689:29-1689:39) ".current =" --> (1059:29-1059:39) ".current =" -(1689:39-1690:4) " null;\n " --> (1059:39-1060:0) " null;" -(1690:4-1690:17) " disableLogs(" --> (1060:0-1060:17) "\n\t\t\t\tdisableLogs(" -(1690:17-1691:3) ");\n " --> (1060:17-1061:3) ");\n\t\t" -(1691:3-1693:2) "}\n\n " --> (1061:3-1062:0) "\t}" -(1693:2-1693:6) " try" --> (1062:0-1062:7) "\n\t\t\ttry" -(1693:6-1695:4) " {\n // This should throw.\n " --> (1062:7-1063:0) " {" -(1695:4-1695:8) " if " --> (1063:0-1063:8) "\n\t\t\t\tif " -(1695:8-1695:19) "(construct)" --> (1063:8-1063:19) "(construct)" -(1695:19-1697:6) " {\n // Something should be setting the props in the constructor.\n " --> (1063:19-1064:5) " {\n\t\t\t\t" -(1697:6-1697:10) " var" --> (1064:5-1064:9) "\tvar" -(1697:10-1697:17) " Fake =" --> (1064:9-1064:16) " Fake =" -(1697:17-1697:29) " function ()" --> (1064:16-1064:27) " function()" -(1697:29-1698:8) " {\n " --> (1064:27-1065:0) " {" -(1698:8-1698:14) " throw" --> (1065:0-1065:12) "\n\t\t\t\t\t\tthrow" -(1698:14-1698:21) " Error(" --> (1065:12-1065:19) " Error(" -(1698:21-1699:7) ");\n " --> (1065:19-1066:5) ");\n\t\t\t\t" -(1699:7-1702:6) "}; // $FlowFixMe\n\n\n " --> (1066:5-1067:0) "\t};" -(1702:6-1702:13) " Object" --> (1067:0-1067:12) "\n\t\t\t\t\tObject" -(1702:13-1702:28) ".defineProperty" --> (1067:12-1067:27) ".defineProperty" -(1702:28-1702:33) "(Fake" --> (1067:27-1067:32) "(Fake" -(1702:33-1702:44) ".prototype," --> (1067:32-1067:43) ".prototype," -(1702:44-1702:53) " 'props'," --> (1067:43-1067:52) " \"props\"," -(1702:53-1703:8) " {\n " --> (1067:52-1067:54) " {" -(1703:8-1703:13) " set:" --> (1067:54-1067:59) " set:" -(1703:13-1703:25) " function ()" --> (1067:59-1067:70) " function()" -(1703:25-1706:10) " {\n // We use a throwing setter instead of frozen or non-writable props\n // because that won't throw in a non-strict mode function.\n " --> (1067:70-1068:0) " {" -(1706:10-1706:16) " throw" --> (1068:0-1068:12) "\n\t\t\t\t\t\tthrow" -(1706:16-1706:23) " Error(" --> (1068:12-1068:19) " Error(" -(1706:23-1707:9) ");\n " --> (1068:19-1069:5) ");\n\t\t\t\t" -(1707:9-1708:7) "}\n " --> (1069:5-1069:7) "\t}" -(1708:7-1708:8) "}" --> (1069:7-1069:9) " }" -(1708:8-1710:6) ");\n\n " --> (1069:9-1070:0) ");" -(1710:6-1710:17) " if (typeof" --> (1070:0-1070:16) "\n\t\t\t\t\tif (typeof" -(1710:17-1710:29) " Reflect ===" --> (1070:16-1070:28) " Reflect ===" -(1710:29-1710:41) " 'object' &&" --> (1070:28-1070:40) " \"object\" &&" -(1710:41-1710:49) " Reflect" --> (1070:40-1070:48) " Reflect" -(1710:49-1710:60) ".construct)" --> (1070:48-1070:59) ".construct)" -(1710:60-1713:8) " {\n // We construct a different control for this case to include any extra\n // frames added by the construct call.\n " --> (1070:59-1071:0) " {" -(1713:8-1713:12) " try" --> (1071:0-1071:10) "\n\t\t\t\t\t\ttry" -(1713:12-1714:10) " {\n " --> (1071:10-1072:0) " {" -(1714:10-1714:18) " Reflect" --> (1072:0-1072:15) "\n\t\t\t\t\t\t\tReflect" -(1714:18-1714:28) ".construct" --> (1072:15-1072:25) ".construct" -(1714:28-1714:34) "(Fake," --> (1072:25-1072:31) "(Fake," -(1714:34-1714:36) " [" --> (1072:31-1072:33) " [" -(1714:36-1714:37) "]" --> (1072:33-1072:34) "]" -(1714:37-1715:9) ");\n " --> (1072:34-1073:6) ");\n\t\t\t\t\t" -(1715:9-1715:17) "} catch " --> (1073:6-1073:15) "\t} catch " -(1715:17-1715:20) "(x)" --> (1073:15-1073:18) "(x)" -(1715:20-1716:10) " {\n " --> (1073:18-1074:0) " {" -(1716:10-1716:20) " control =" --> (1074:0-1074:17) "\n\t\t\t\t\t\t\tcontrol =" -(1716:20-1717:9) " x;\n " --> (1074:17-1075:6) " x;\n\t\t\t\t\t" -(1717:9-1719:8) "}\n\n " --> (1075:6-1076:0) "\t}" -(1719:8-1719:16) " Reflect" --> (1076:0-1076:14) "\n\t\t\t\t\t\tReflect" -(1719:16-1719:26) ".construct" --> (1076:14-1076:24) ".construct" -(1719:26-1719:30) "(fn," --> (1076:24-1076:28) "(fn," -(1719:30-1719:32) " [" --> (1076:28-1076:30) " [" -(1719:32-1719:34) "]," --> (1076:30-1076:32) "]," -(1719:34-1719:39) " Fake" --> (1076:32-1076:37) " Fake" -(1719:39-1720:7) ");\n " --> (1076:37-1077:5) ");\n\t\t\t\t" -(1720:7-1720:13) "} else" --> (1077:5-1077:12) "\t} else" -(1720:13-1721:8) " {\n " --> (1077:12-1078:0) " {" -(1721:8-1721:12) " try" --> (1078:0-1078:10) "\n\t\t\t\t\t\ttry" -(1721:12-1722:10) " {\n " --> (1078:10-1079:0) " {" -(1722:10-1722:15) " Fake" --> (1079:0-1079:12) "\n\t\t\t\t\t\t\tFake" -(1722:15-1722:21) ".call(" --> (1079:12-1079:18) ".call(" -(1722:21-1723:9) ");\n " --> (1079:18-1080:6) ");\n\t\t\t\t\t" -(1723:9-1723:17) "} catch " --> (1080:6-1080:15) "\t} catch " -(1723:17-1723:20) "(x)" --> (1080:15-1080:18) "(x)" -(1723:20-1724:10) " {\n " --> (1080:18-1081:0) " {" -(1724:10-1724:20) " control =" --> (1081:0-1081:17) "\n\t\t\t\t\t\t\tcontrol =" -(1724:20-1725:9) " x;\n " --> (1081:17-1082:6) " x;\n\t\t\t\t\t" -(1725:9-1727:8) "}\n\n " --> (1082:6-1083:0) "\t}" -(1727:8-1727:11) " fn" --> (1083:0-1083:9) "\n\t\t\t\t\t\tfn" -(1727:11-1727:16) ".call" --> (1083:9-1083:14) ".call" -(1727:16-1727:21) "(Fake" --> (1083:14-1083:19) "(Fake" -(1727:21-1727:31) ".prototype" --> (1083:19-1083:29) ".prototype" -(1727:31-1728:7) ");\n " --> (1083:29-1084:5) ");\n\t\t\t\t" -(1728:7-1729:5) "}\n " --> (1084:5-1085:4) "\t}\n\t\t\t" -(1729:5-1729:11) "} else" --> (1085:4-1085:11) "\t} else" -(1729:11-1730:6) " {\n " --> (1085:11-1086:0) " {" -(1730:6-1730:10) " try" --> (1086:0-1086:9) "\n\t\t\t\t\ttry" -(1730:10-1731:8) " {\n " --> (1086:9-1087:0) " {" -(1731:8-1731:14) " throw" --> (1087:0-1087:12) "\n\t\t\t\t\t\tthrow" -(1731:14-1731:21) " Error(" --> (1087:12-1087:19) " Error(" -(1731:21-1732:7) ");\n " --> (1087:19-1088:5) ");\n\t\t\t\t" -(1732:7-1732:15) "} catch " --> (1088:5-1088:14) "\t} catch " -(1732:15-1732:18) "(x)" --> (1088:14-1088:17) "(x)" -(1732:18-1733:8) " {\n " --> (1088:17-1089:0) " {" -(1733:8-1733:18) " control =" --> (1089:0-1089:16) "\n\t\t\t\t\t\tcontrol =" -(1733:18-1734:7) " x;\n " --> (1089:16-1090:5) " x;\n\t\t\t\t" -(1734:7-1736:6) "}\n\n " --> (1090:5-1091:0) "\t}" -(1736:6-1736:10) " fn(" --> (1091:0-1091:9) "\n\t\t\t\t\tfn(" -(1736:10-1737:5) ");\n " --> (1091:9-1092:4) ");\n\t\t\t" -(1737:5-1738:3) "}\n " --> (1092:4-1093:3) "\t}\n\t\t" -(1738:3-1738:11) "} catch " --> (1093:3-1093:12) "\t} catch " -(1738:11-1738:19) "(sample)" --> (1093:12-1093:20) "(sample)" -(1738:19-1740:4) " {\n // This is inlined manually because closure doesn't do it for us.\n " --> (1093:20-1094:0) " {" -(1740:4-1740:8) " if " --> (1094:0-1094:8) "\n\t\t\t\tif " -(1740:8-1740:18) "(sample &&" --> (1094:8-1094:18) "(sample &&" -(1740:18-1740:36) " control && typeof" --> (1094:18-1094:36) " control && typeof" -(1740:36-1740:43) " sample" --> (1094:36-1094:43) " sample" -(1740:43-1740:53) ".stack ===" --> (1094:43-1094:53) ".stack ===" -(1740:53-1740:63) " 'string')" --> (1094:53-1094:63) " \"string\")" -(1740:63-1743:6) " {\n // This extracts the first frame from the sample that isn't also in the control.\n // Skipping one frame that we assume is the frame that calls the two.\n " --> (1094:63-1095:5) " {\n\t\t\t\t" -(1743:6-1743:10) " var" --> (1095:5-1095:9) "\tvar" -(1743:10-1743:24) " sampleLines =" --> (1095:9-1095:23) " sampleLines =" -(1743:24-1743:31) " sample" --> (1095:23-1095:30) " sample" -(1743:31-1743:37) ".stack" --> (1095:30-1095:36) ".stack" -(1743:37-1743:43) ".split" --> (1095:36-1095:42) ".split" -(1743:43-1743:48) "('\\n'" --> (1095:42-1095:47) "(\"\\n\"" -(1743:48-1744:6) ");\n " --> (1095:47-1096:5) ");\n\t\t\t\t" -(1744:6-1744:10) " var" --> (1096:5-1096:9) "\tvar" -(1744:10-1744:25) " controlLines =" --> (1096:9-1096:24) " controlLines =" -(1744:25-1744:33) " control" --> (1096:24-1096:32) " control" -(1744:33-1744:39) ".stack" --> (1096:32-1096:38) ".stack" -(1744:39-1744:45) ".split" --> (1096:38-1096:44) ".split" -(1744:45-1744:50) "('\\n'" --> (1096:44-1096:49) "(\"\\n\"" -(1744:50-1745:6) ");\n " --> (1096:49-1097:5) ");\n\t\t\t\t" -(1745:6-1745:10) " var" --> (1097:5-1097:9) "\tvar" -(1745:10-1745:14) " s =" --> (1097:9-1097:13) " s =" -(1745:14-1745:26) " sampleLines" --> (1097:13-1097:25) " sampleLines" -(1745:26-1745:35) ".length -" --> (1097:25-1097:34) ".length -" -(1745:35-1746:6) " 1;\n " --> (1097:34-1098:5) " 1;\n\t\t\t\t" -(1746:6-1746:10) " var" --> (1098:5-1098:9) "\tvar" -(1746:10-1746:14) " c =" --> (1098:9-1098:13) " c =" -(1746:14-1746:27) " controlLines" --> (1098:13-1098:26) " controlLines" -(1746:27-1746:36) ".length -" --> (1098:26-1098:35) ".length -" -(1746:36-1748:6) " 1;\n\n " --> (1098:35-1099:0) " 1;" -(1748:6-1748:13) " while " --> (1099:0-1099:12) "\n\t\t\t\t\twhile " -(1748:13-1748:18) "(s >=" --> (1099:12-1099:17) "(s >=" -(1748:18-1748:23) " 1 &&" --> (1099:17-1099:22) " 1 &&" -(1748:23-1748:28) " c >=" --> (1099:22-1099:27) " c >=" -(1748:28-1748:33) " 0 &&" --> (1099:27-1099:32) " 0 &&" -(1748:33-1748:45) " sampleLines" --> (1099:32-1099:44) " sampleLines" -(1748:45-1748:52) "[s] !==" --> (1099:44-1099:51) "[s] !==" -(1748:52-1748:65) " controlLines" --> (1099:51-1099:64) " controlLines" -(1748:65-1748:69) "[c])" --> (1099:64-1099:68) "[c])" -(1748:69-1755:8) " {\n // We expect at least one stack frame to be shared.\n // Typically this will be the root most one. However, stack frames may be\n // cut off due to maximum stack limits. In this case, one maybe cut off\n // earlier than the other. We assume that the sample is longer or the same\n // and there for cut off earlier. So we should find the root most frame in\n // the sample somewhere in the control.\n " --> (1099:68-1100:0) " {" -(1755:8-1756:7) " c--;\n " --> (1100:0-1101:5) "\n\t\t\t\t\t\tc--;\n\t\t\t\t" -(1756:7-1758:6) "}\n\n " --> (1101:5-1102:0) "\t}" -(1758:6-1758:13) " for (;" --> (1102:0-1102:12) "\n\t\t\t\t\tfor (;" -(1758:13-1758:18) " s >=" --> (1102:12-1102:17) " s >=" -(1758:18-1758:23) " 1 &&" --> (1102:17-1102:22) " 1 &&" -(1758:23-1758:28) " c >=" --> (1102:22-1102:27) " c >=" -(1758:28-1758:31) " 0;" --> (1102:27-1102:30) " 0;" -(1758:31-1758:36) " s--," --> (1102:30-1102:35) " s--," -(1758:36-1758:41) " c--)" --> (1102:35-1102:40) " c--)" -(1758:41-1761:8) " {\n // Next we find the first one that isn't the same which should be the\n // frame that called our sample function and the control.\n " --> (1102:40-1103:0) " {" -(1761:8-1761:12) " if " --> (1103:0-1103:10) "\n\t\t\t\t\t\tif " -(1761:12-1761:24) "(sampleLines" --> (1103:10-1103:22) "(sampleLines" -(1761:24-1761:31) "[s] !==" --> (1103:22-1103:29) "[s] !==" -(1761:31-1761:44) " controlLines" --> (1103:29-1103:42) " controlLines" -(1761:44-1761:48) "[c])" --> (1103:42-1103:46) "[c])" -(1761:48-1767:10) " {\n // In V8, the first line is describing the message but other VMs don't.\n // If we're about to return the first line, and the control is also on the same\n // line, that's a pretty good indicator that our sample threw at same line as\n // the control. I.e. before we entered the sample frame. So we ignore this result.\n // This can happen if you passed a class to function component, or non-function.\n " --> (1103:46-1104:0) " {" -(1767:10-1767:14) " if " --> (1104:0-1104:11) "\n\t\t\t\t\t\t\tif " -(1767:14-1767:20) "(s !==" --> (1104:11-1104:17) "(s !==" -(1767:20-1767:25) " 1 ||" --> (1104:17-1104:22) " 1 ||" -(1767:25-1767:31) " c !==" --> (1104:22-1104:28) " c !==" -(1767:31-1767:34) " 1)" --> (1104:28-1104:31) " 1)" -(1767:34-1768:12) " {\n " --> (1104:31-1105:0) " {" -(1768:12-1768:15) " do" --> (1105:0-1105:11) "\n\t\t\t\t\t\t\t\tdo" -(1768:15-1769:14) " {\n " --> (1105:11-1106:0) " {" -(1769:14-1770:14) " s--;\n " --> (1106:0-1107:0) "\n\t\t\t\t\t\t\t\t\ts--;" -(1770:14-1773:14) " c--; // We may still have similar intermediate frames from the construct call.\n // The next one that isn't the same should be our match though.\n\n " --> (1107:0-1108:0) "\n\t\t\t\t\t\t\t\t\tc--;" -(1773:14-1773:18) " if " --> (1108:0-1108:13) "\n\t\t\t\t\t\t\t\t\tif " -(1773:18-1773:22) "(c <" --> (1108:13-1108:17) "(c <" -(1773:22-1773:27) " 0 ||" --> (1108:17-1108:22) " 0 ||" -(1773:27-1773:39) " sampleLines" --> (1108:22-1108:34) " sampleLines" -(1773:39-1773:46) "[s] !==" --> (1108:34-1108:41) "[s] !==" -(1773:46-1773:59) " controlLines" --> (1108:41-1108:54) " controlLines" -(1773:59-1773:63) "[c])" --> (1108:54-1108:58) "[c])" -(1773:63-1775:16) " {\n // V8 adds a \"new\" prefix for native classes. Let's remove it to make it prettier.\n " --> (1108:58-1109:10) " {\n\t\t\t\t\t\t\t\t\t" -(1775:16-1775:20) " var" --> (1109:10-1109:14) "\tvar" -(1775:20-1775:29) " _frame =" --> (1109:14-1109:23) " _frame =" -(1775:29-1775:36) " '\\n' +" --> (1109:23-1109:30) " \"\\n\" +" -(1775:36-1775:48) " sampleLines" --> (1109:30-1109:42) " sampleLines" -(1775:48-1775:51) "[s]" --> (1109:42-1109:45) "[s]" -(1775:51-1775:59) ".replace" --> (1109:45-1109:53) ".replace" -(1775:59-1775:71) "(' at new '," --> (1109:53-1109:65) "(\" at new \"," -(1775:71-1775:78) " ' at '" --> (1109:65-1109:72) " \" at \"" -(1775:78-1777:16) ");\n\n " --> (1109:72-1110:10) ");\n\t\t\t\t\t\t\t\t\t" -(1777:16-1778:18) " {\n " --> (1110:10-1111:0) "\t{" -(1778:18-1778:29) " if (typeof" --> (1111:0-1111:22) "\n\t\t\t\t\t\t\t\t\t\t\tif (typeof" -(1778:29-1778:36) " fn ===" --> (1111:22-1111:29) " fn ===" -(1778:36-1778:48) " 'function')" --> (1111:29-1111:41) " \"function\")" -(1778:48-1779:20) " {\n " --> (1111:41-1112:0) " {" -(1779:20-1779:40) " componentFrameCache" --> (1112:0-1112:32) "\n\t\t\t\t\t\t\t\t\t\t\t\tcomponentFrameCache" -(1779:40-1779:44) ".set" --> (1112:32-1112:36) ".set" -(1779:44-1779:48) "(fn," --> (1112:36-1112:40) "(fn," -(1779:48-1779:55) " _frame" --> (1112:40-1112:47) " _frame" -(1779:55-1780:19) ");\n " --> (1112:47-1113:11) ");\n\t\t\t\t\t\t\t\t\t\t" -(1780:19-1781:17) "}\n " --> (1113:11-1114:10) "\t}\n\t\t\t\t\t\t\t\t\t" -(1781:17-1784:16) "} // Return the line we found.\n\n\n " --> (1114:10-1115:0) "\t}" -(1784:16-1784:23) " return" --> (1115:0-1115:17) "\n\t\t\t\t\t\t\t\t\t\treturn" -(1784:23-1785:15) " _frame;\n " --> (1115:17-1116:9) " _frame;\n\t\t\t\t\t\t\t\t" -(1785:15-1786:13) "}\n " --> (1116:9-1117:8) "\t}\n\t\t\t\t\t\t\t" -(1786:13-1786:21) "} while " --> (1117:8-1117:17) "\t} while " -(1786:21-1786:26) "(s >=" --> (1117:17-1117:22) "(s >=" -(1786:26-1786:31) " 1 &&" --> (1117:22-1117:27) " 1 &&" -(1786:31-1786:36) " c >=" --> (1117:27-1117:32) " c >=" -(1786:36-1787:11) " 0);\n " --> (1117:32-1118:7) " 0);\n\t\t\t\t\t\t" -(1787:11-1789:10) "}\n\n " --> (1118:7-1119:0) "\t}" -(1789:10-1790:9) " break;\n " --> (1119:0-1120:6) "\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t" -(1790:9-1791:7) "}\n " --> (1120:6-1121:5) "\t}\n\t\t\t\t" -(1791:7-1792:5) "}\n " --> (1121:5-1122:4) "\t}\n\t\t\t" -(1792:5-1793:3) "}\n " --> (1122:4-1123:3) "\t}\n\t\t" -(1793:3-1793:12) "} finally" --> (1123:3-1124:9) "\t}\n finally" -(1793:12-1794:4) " {\n " --> (1124:9-1125:0) " {" -(1794:4-1794:14) " reentry =" --> (1125:0-1125:14) "\n\t\t\t\treentry =" -(1794:14-1796:4) " false;\n\n " --> (1125:14-1126:4) " false;\n\t\t\t" -(1796:4-1797:6) " {\n " --> (1126:4-1127:0) "\t{" -(1797:6-1797:31) " ReactCurrentDispatcher$1" --> (1127:0-1127:30) "\n\t\t\t\t\tReactCurrentDispatcher$1" -(1797:31-1797:41) ".current =" --> (1127:30-1127:40) ".current =" -(1797:41-1798:6) " previousDispatcher;\n " --> (1127:40-1128:0) " previousDispatcher;" -(1798:6-1798:20) " reenableLogs(" --> (1128:0-1128:19) "\n\t\t\t\t\treenableLogs(" -(1798:20-1799:5) ");\n " --> (1128:19-1129:4) ");\n\t\t\t" -(1799:5-1801:4) "}\n\n " --> (1129:4-1130:0) "\t}" -(1801:4-1801:10) " Error" --> (1130:0-1130:10) "\n\t\t\t\tError" -(1801:10-1801:30) ".prepareStackTrace =" --> (1130:10-1130:30) ".prepareStackTrace =" -(1801:30-1802:3) " previousPrepareStackTrace;\n " --> (1130:30-1131:3) " previousPrepareStackTrace;\n\t\t" -(1802:3-1805:2) "} // Fallback to just using the name if we couldn't make it throw.\n\n\n " --> (1131:3-1132:3) "\t}\n\t\t" -(1805:2-1805:6) " var" --> (1132:3-1132:7) "\tvar" -(1805:6-1805:13) " name =" --> (1132:7-1132:14) " name =" -(1805:13-1805:18) " fn ?" --> (1132:14-1132:19) " fn ?" -(1805:18-1805:21) " fn" --> (1132:19-1132:22) " fn" -(1805:21-1805:36) ".displayName ||" --> (1132:22-1132:37) ".displayName ||" -(1805:36-1805:39) " fn" --> (1132:37-1132:40) " fn" -(1805:39-1805:46) ".name :" --> (1132:40-1132:47) ".name :" -(1805:46-1806:2) " '';\n " --> (1132:47-1133:3) " \"\";\n\t\t" -(1806:2-1806:6) " var" --> (1133:3-1133:7) "\tvar" -(1806:6-1806:23) " syntheticFrame =" --> (1133:7-1133:24) " syntheticFrame =" -(1806:23-1806:30) " name ?" --> (1133:24-1133:31) " name ?" -(1806:30-1806:60) " describeBuiltInComponentFrame" --> (1133:31-1133:61) " describeBuiltInComponentFrame" -(1806:60-1806:65) "(name" --> (1133:61-1133:66) "(name" -(1806:65-1806:68) ") :" --> (1133:66-1133:69) ") :" -(1806:68-1808:2) " '';\n\n " --> (1133:69-1134:3) " \"\";\n\t\t" -(1808:2-1809:4) " {\n " --> (1134:3-1135:0) "\t{" -(1809:4-1809:15) " if (typeof" --> (1135:0-1135:15) "\n\t\t\t\tif (typeof" -(1809:15-1809:22) " fn ===" --> (1135:15-1135:22) " fn ===" -(1809:22-1809:34) " 'function')" --> (1135:22-1135:34) " \"function\")" -(1809:34-1810:6) " {\n " --> (1135:34-1136:0) " {" -(1810:6-1810:26) " componentFrameCache" --> (1136:0-1136:25) "\n\t\t\t\t\tcomponentFrameCache" -(1810:26-1810:30) ".set" --> (1136:25-1136:29) ".set" -(1810:30-1810:34) "(fn," --> (1136:29-1136:33) "(fn," -(1810:34-1810:49) " syntheticFrame" --> (1136:33-1136:48) " syntheticFrame" -(1810:49-1811:5) ");\n " --> (1136:48-1137:4) ");\n\t\t\t" -(1811:5-1812:3) "}\n " --> (1137:4-1138:3) "\t}\n\t\t" -(1812:3-1814:2) "}\n\n " --> (1138:3-1139:0) "\t}" -(1814:2-1814:9) " return" --> (1139:0-1139:10) "\n\t\t\treturn" -(1814:9-1815:1) " syntheticFrame;\n" --> (1139:10-1140:2) " syntheticFrame;\n\t" -(1815:1-1816:0) "}" --> (1140:2-1141:2) "\t}\n\t" -(1816:0-1816:9) "\nfunction" --> (1141:2-1141:11) "\tfunction" -(1816:9-1816:40) " describeFunctionComponentFrame" --> (1141:11-1141:42) " describeFunctionComponentFrame" -(1816:40-1816:44) "(fn," --> (1141:42-1141:46) "(fn," -(1816:44-1816:52) " source," --> (1141:46-1141:54) " source," -(1816:52-1816:61) " ownerFn)" --> (1141:54-1141:63) " ownerFn)" -(1816:61-1817:2) " {\n " --> (1141:63-1142:3) " {\n\t\t" -(1817:2-1818:4) " {\n " --> (1142:3-1143:0) "\t{" -(1818:4-1818:11) " return" --> (1143:0-1143:11) "\n\t\t\t\treturn" -(1818:11-1818:40) " describeNativeComponentFrame" --> (1143:11-1143:40) " describeNativeComponentFrame" -(1818:40-1818:44) "(fn," --> (1143:40-1143:44) "(fn," -(1818:44-1818:50) " false" --> (1143:44-1143:50) " false" -(1818:50-1819:3) ");\n " --> (1143:50-1144:3) ");\n\t\t" -(1819:3-1820:1) "}\n" --> (1144:3-1145:2) "\t}\n\t" -(1820:1-1822:0) "}\n" --> (1145:2-1146:2) "\t}\n\t" -(1822:0-1822:9) "\nfunction" --> (1146:2-1146:11) "\tfunction" -(1822:9-1822:25) " shouldConstruct" --> (1146:11-1146:27) " shouldConstruct" -(1822:25-1822:36) "(Component)" --> (1146:27-1146:38) "(Component)" -(1822:36-1823:2) " {\n " --> (1146:38-1147:3) " {\n\t\t" -(1823:2-1823:6) " var" --> (1147:3-1147:7) "\tvar" -(1823:6-1823:18) " prototype =" --> (1147:7-1147:19) " prototype =" -(1823:18-1823:28) " Component" --> (1147:19-1147:29) " Component" -(1823:28-1824:2) ".prototype;\n " --> (1147:29-1148:0) ".prototype;" -(1824:2-1824:12) " return !!" --> (1148:0-1148:13) "\n\t\t\treturn !!" -(1824:12-1824:25) "(prototype &&" --> (1148:13-1148:26) "(prototype &&" -(1824:25-1824:35) " prototype" --> (1148:26-1148:36) " prototype" -(1824:35-1825:1) ".isReactComponent);\n" --> (1148:36-1149:2) ".isReactComponent);\n\t" -(1825:1-1827:0) "}\n" --> (1149:2-1150:2) "\t}\n\t" -(1827:0-1827:9) "\nfunction" --> (1150:2-1150:11) "\tfunction" -(1827:9-1827:46) " describeUnknownElementTypeFrameInDEV" --> (1150:11-1150:48) " describeUnknownElementTypeFrameInDEV" -(1827:46-1827:52) "(type," --> (1150:48-1150:54) "(type," -(1827:52-1827:60) " source," --> (1150:54-1150:62) " source," -(1827:60-1827:69) " ownerFn)" --> (1150:62-1150:71) " ownerFn)" -(1827:69-1829:2) " {\n\n " --> (1150:71-1151:0) " {" -(1829:2-1829:6) " if " --> (1151:0-1151:7) "\n\t\t\tif " -(1829:6-1829:14) "(type ==" --> (1151:7-1151:15) "(type ==" -(1829:14-1829:20) " null)" --> (1151:15-1151:21) " null)" -(1829:20-1830:4) " {\n " --> (1151:21-1152:0) " {" -(1830:4-1830:11) " return" --> (1152:0-1152:11) "\n\t\t\t\treturn" -(1830:11-1831:3) " '';\n " --> (1152:11-1153:3) " \"\";\n\t\t" -(1831:3-1833:2) "}\n\n " --> (1153:3-1154:0) "\t}" -(1833:2-1833:13) " if (typeof" --> (1154:0-1154:14) "\n\t\t\tif (typeof" -(1833:13-1833:22) " type ===" --> (1154:14-1154:23) " type ===" -(1833:22-1833:34) " 'function')" --> (1154:23-1154:35) " \"function\")" -(1833:34-1834:4) " {\n " --> (1154:35-1155:4) " {\n\t\t\t" -(1834:4-1835:6) " {\n " --> (1155:4-1156:0) "\t{" -(1835:6-1835:13) " return" --> (1156:0-1156:12) "\n\t\t\t\t\treturn" -(1835:13-1835:42) " describeNativeComponentFrame" --> (1156:12-1156:41) " describeNativeComponentFrame" -(1835:42-1835:48) "(type," --> (1156:41-1156:47) "(type," -(1835:48-1835:64) " shouldConstruct" --> (1156:47-1156:63) " shouldConstruct" -(1835:64-1835:69) "(type" --> (1156:63-1156:68) "(type" -(1835:69-1835:70) ")" --> (1156:68-1156:69) ")" -(1835:70-1836:5) ");\n " --> (1156:69-1157:4) ");\n\t\t\t" -(1836:5-1837:3) "}\n " --> (1157:4-1158:3) "\t}\n\t\t" -(1837:3-1839:2) "}\n\n " --> (1158:3-1159:0) "\t}" -(1839:2-1839:13) " if (typeof" --> (1159:0-1159:14) "\n\t\t\tif (typeof" -(1839:13-1839:22) " type ===" --> (1159:14-1159:23) " type ===" -(1839:22-1839:32) " 'string')" --> (1159:23-1159:33) " \"string\")" -(1839:32-1840:4) " {\n " --> (1159:33-1160:0) " {" -(1840:4-1840:11) " return" --> (1160:0-1160:11) "\n\t\t\t\treturn" -(1840:11-1840:41) " describeBuiltInComponentFrame" --> (1160:11-1160:41) " describeBuiltInComponentFrame" -(1840:41-1840:46) "(type" --> (1160:41-1160:46) "(type" -(1840:46-1841:3) ");\n " --> (1160:46-1161:3) ");\n\t\t" -(1841:3-1843:2) "}\n\n " --> (1161:3-1162:0) "\t}" -(1843:2-1843:10) " switch " --> (1162:0-1162:11) "\n\t\t\tswitch " -(1843:10-1843:2) " switch " --> (1162:11-1162:17) "(type)" -(1843:2-1844:4) " switch (type) {\n " --> (1162:17-1163:0) " {" -(1844:4-1844:9) " case" --> (1163:0-1163:9) "\n\t\t\t\tcase" -(1844:9-1844:17) " exports" --> (1163:9-1163:17) " exports" -(1844:17-1845:6) ".Suspense:\n " --> (1163:17-1163:26) ".Suspense" -(1845:6-1845:13) " return" --> (1163:26-1163:34) ": return" -(1845:13-1845:43) " describeBuiltInComponentFrame" --> (1163:34-1163:64) " describeBuiltInComponentFrame" -(1845:43-1845:54) "('Suspense'" --> (1163:64-1163:75) "(\"Suspense\"" -(1845:54-1847:4) ");\n\n " --> (1163:75-1164:0) ");" -(1847:4-1847:9) " case" --> (1164:0-1164:9) "\n\t\t\t\tcase" -(1847:9-1848:6) " REACT_SUSPENSE_LIST_TYPE:\n " --> (1164:9-1164:34) " REACT_SUSPENSE_LIST_TYPE" -(1848:6-1848:13) " return" --> (1164:34-1164:42) ": return" -(1848:13-1848:43) " describeBuiltInComponentFrame" --> (1164:42-1164:72) " describeBuiltInComponentFrame" -(1848:43-1848:58) "('SuspenseList'" --> (1164:72-1164:87) "(\"SuspenseList\"" -(1848:58-1849:3) ");\n " --> (1164:87-1165:3) ");\n\t\t" -(1849:3-1851:2) "}\n\n " --> (1165:3-1166:0) "\t}" -(1851:2-1851:13) " if (typeof" --> (1166:0-1166:14) "\n\t\t\tif (typeof" -(1851:13-1851:22) " type ===" --> (1166:14-1166:23) " type ===" -(1851:22-1851:32) " 'object')" --> (1166:23-1166:33) " \"object\")" -(1851:32-1852:4) " {\n " --> (1166:33-1167:0) " {" -(1852:4-1852:12) " switch " --> (1167:0-1167:12) "\n\t\t\t\tswitch " -(1852:12-1852:17) "(type" --> (1167:12-1167:17) "(type" -(1852:17-1852:4) " switch (type" --> (1167:17-1167:27) ".$$typeof)" -(1852:4-1853:6) " switch (type.$$typeof) {\n " --> (1167:27-1168:0) " {" -(1853:6-1853:11) " case" --> (1168:0-1168:10) "\n\t\t\t\t\tcase" -(1853:11-1854:8) " REACT_FORWARD_REF_TYPE:\n " --> (1168:10-1168:33) " REACT_FORWARD_REF_TYPE" -(1854:8-1854:15) " return" --> (1168:33-1168:41) ": return" -(1854:15-1854:46) " describeFunctionComponentFrame" --> (1168:41-1168:72) " describeFunctionComponentFrame" -(1854:46-1854:51) "(type" --> (1168:72-1168:77) "(type" -(1854:51-1854:58) ".render" --> (1168:77-1168:84) ".render" -(1854:58-1856:6) ");\n\n " --> (1168:84-1169:0) ");" -(1856:6-1856:11) " case" --> (1169:0-1169:10) "\n\t\t\t\t\tcase" -(1856:11-1858:8) " REACT_MEMO_TYPE:\n // Memo may contain any component type so we recursively resolve it.\n " --> (1169:10-1169:26) " REACT_MEMO_TYPE" -(1858:8-1858:15) " return" --> (1169:26-1169:34) ": return" -(1858:15-1858:52) " describeUnknownElementTypeFrameInDEV" --> (1169:34-1169:71) " describeUnknownElementTypeFrameInDEV" -(1858:52-1858:57) "(type" --> (1169:71-1169:76) "(type" -(1858:57-1858:63) ".type," --> (1169:76-1169:82) ".type," -(1858:63-1858:71) " source," --> (1169:82-1169:90) " source," -(1858:71-1858:79) " ownerFn" --> (1169:90-1169:98) " ownerFn" -(1858:79-1860:6) ");\n\n " --> (1169:98-1170:0) ");" -(1860:6-1860:11) " case" --> (1170:0-1170:10) "\n\t\t\t\t\tcase" -(1860:11-1861:8) " REACT_BLOCK_TYPE:\n " --> (1170:10-1170:27) " REACT_BLOCK_TYPE" -(1861:8-1861:15) " return" --> (1170:27-1170:35) ": return" -(1861:15-1861:46) " describeFunctionComponentFrame" --> (1170:35-1170:66) " describeFunctionComponentFrame" -(1861:46-1861:51) "(type" --> (1170:66-1170:71) "(type" -(1861:51-1861:59) "._render" --> (1170:71-1170:79) "._render" -(1861:59-1863:6) ");\n\n " --> (1170:79-1171:0) ");" -(1863:6-1863:11) " case" --> (1171:0-1171:10) "\n\t\t\t\t\tcase" -(1863:11-1864:8) " REACT_LAZY_TYPE:\n " --> (1171:10-1171:27) " REACT_LAZY_TYPE:" -(1864:8-1865:10) " {\n " --> (1171:27-1172:6) " {\n\t\t\t\t\t" -(1865:10-1865:14) " var" --> (1172:6-1172:10) "\tvar" -(1865:14-1865:30) " lazyComponent =" --> (1172:10-1172:26) " lazyComponent =" -(1865:30-1866:10) " type;\n " --> (1172:26-1173:6) " type;\n\t\t\t\t\t" -(1866:10-1866:14) " var" --> (1173:6-1173:10) "\tvar" -(1866:14-1866:24) " payload =" --> (1173:10-1173:20) " payload =" -(1866:24-1866:38) " lazyComponent" --> (1173:20-1173:34) " lazyComponent" -(1866:38-1867:10) "._payload;\n " --> (1173:34-1174:6) "._payload;\n\t\t\t\t\t" -(1867:10-1867:14) " var" --> (1174:6-1174:10) "\tvar" -(1867:14-1867:21) " init =" --> (1174:10-1174:17) " init =" -(1867:21-1867:35) " lazyComponent" --> (1174:17-1174:31) " lazyComponent" -(1867:35-1869:10) "._init;\n\n " --> (1174:31-1175:0) "._init;" -(1869:10-1869:14) " try" --> (1175:0-1175:10) "\n\t\t\t\t\t\ttry" -(1869:14-1871:12) " {\n // Lazy may contain any component type so we recursively resolve it.\n " --> (1175:10-1176:0) " {" -(1871:12-1871:19) " return" --> (1176:0-1176:14) "\n\t\t\t\t\t\t\treturn" -(1871:19-1871:56) " describeUnknownElementTypeFrameInDEV" --> (1176:14-1176:51) " describeUnknownElementTypeFrameInDEV" -(1871:56-1871:61) "(init" --> (1176:51-1176:56) "(init" -(1871:61-1871:69) "(payload" --> (1176:56-1176:64) "(payload" -(1871:69-1871:71) ")," --> (1176:64-1176:66) ")," -(1871:71-1871:79) " source," --> (1176:66-1176:74) " source," -(1871:79-1871:87) " ownerFn" --> (1176:74-1176:82) " ownerFn" -(1871:87-1872:11) ");\n " --> (1176:82-1177:6) ");\n\t\t\t\t\t" -(1872:11-1872:19) "} catch " --> (1177:6-1177:15) "\t} catch " -(1872:19-1872:22) "(x)" --> (1177:15-1177:18) "(x)" -(1872:22-1872:24) " {" --> (1177:18-1177:19) " " -(1872:24-1873:9) "}\n " --> (1177:19-1178:5) "{}\n\t\t\t\t" -(1873:9-1874:5) "}\n " --> (1178:5-1179:4) "\t}\n\t\t\t" -(1874:5-1875:3) "}\n " --> (1179:4-1180:3) "\t}\n\t\t" -(1875:3-1877:2) "}\n\n " --> (1180:3-1181:0) "\t}" -(1877:2-1877:9) " return" --> (1181:0-1181:10) "\n\t\t\treturn" -(1877:9-1878:1) " '';\n" --> (1181:10-1182:2) " \"\";\n\t" -(1878:1-1880:0) "}\n" --> (1182:2-1183:2) "\t}\n\t" -(1880:0-1880:4) "\nvar" --> (1183:2-1183:6) "\tvar" -(1880:4-1880:25) " loggedTypeFailures =" --> (1183:6-1183:27) " loggedTypeFailures =" -(1880:25-1880:27) " {" --> (1183:27-1183:28) " " -(1880:27-1881:0) "};" --> (1183:28-1184:2) "{};\n\t" -(1881:0-1881:4) "\nvar" --> (1184:2-1184:6) "\tvar" -(1881:4-1881:31) " ReactDebugCurrentFrame$1 =" --> (1184:6-1184:33) " ReactDebugCurrentFrame$1 =" -(1881:31-1881:52) " ReactSharedInternals" --> (1184:33-1184:54) " ReactSharedInternals" -(1881:52-1883:0) ".ReactDebugCurrentFrame;\n" --> (1184:54-1185:2) ".ReactDebugCurrentFrame;\n\t" -(1883:0-1883:9) "\nfunction" --> (1185:2-1185:11) "\tfunction" -(1883:9-1883:39) " setCurrentlyValidatingElement" --> (1185:11-1185:41) " setCurrentlyValidatingElement" -(1883:39-1883:48) "(element)" --> (1185:41-1185:50) "(element)" -(1883:48-1884:2) " {\n " --> (1185:50-1186:3) " {\n\t\t" -(1884:2-1885:4) " {\n " --> (1186:3-1187:0) "\t{" -(1885:4-1885:8) " if " --> (1187:0-1187:8) "\n\t\t\t\tif " -(1885:8-1885:17) "(element)" --> (1187:8-1187:17) "(element)" -(1885:17-1886:6) " {\n " --> (1187:17-1188:5) " {\n\t\t\t\t" -(1886:6-1886:10) " var" --> (1188:5-1188:9) "\tvar" -(1886:10-1886:18) " owner =" --> (1188:9-1188:17) " owner =" -(1886:18-1886:26) " element" --> (1188:17-1188:25) " element" -(1886:26-1887:6) "._owner;\n " --> (1188:25-1189:5) "._owner;\n\t\t\t\t" -(1887:6-1887:10) " var" --> (1189:5-1189:9) "\tvar" -(1887:10-1887:18) " stack =" --> (1189:9-1189:17) " stack =" -(1887:18-1887:55) " describeUnknownElementTypeFrameInDEV" --> (1189:17-1189:54) " describeUnknownElementTypeFrameInDEV" -(1887:55-1887:63) "(element" --> (1189:54-1189:62) "(element" -(1887:63-1887:69) ".type," --> (1189:62-1189:68) ".type," -(1887:69-1887:77) " element" --> (1189:68-1189:76) " element" -(1887:77-1887:86) "._source," --> (1189:76-1189:85) "._source," -(1887:86-1887:94) " owner ?" --> (1189:85-1189:93) " owner ?" -(1887:94-1887:100) " owner" --> (1189:93-1189:99) " owner" -(1887:100-1887:107) ".type :" --> (1189:99-1189:106) ".type :" -(1887:107-1887:112) " null" --> (1189:106-1189:111) " null" -(1887:112-1888:6) ");\n " --> (1189:111-1190:0) ");" -(1888:6-1888:31) " ReactDebugCurrentFrame$1" --> (1190:0-1190:30) "\n\t\t\t\t\tReactDebugCurrentFrame$1" -(1888:31-1888:50) ".setExtraStackFrame" --> (1190:30-1190:49) ".setExtraStackFrame" -(1888:50-1888:56) "(stack" --> (1190:49-1190:55) "(stack" -(1888:56-1889:5) ");\n " --> (1190:55-1191:4) ");\n\t\t\t" -(1889:5-1889:11) "} else" --> (1191:4-1191:11) "\t} else" -(1889:11-1890:6) " {\n " --> (1191:11-1192:0) " {" -(1890:6-1890:31) " ReactDebugCurrentFrame$1" --> (1192:0-1192:30) "\n\t\t\t\t\tReactDebugCurrentFrame$1" -(1890:31-1890:50) ".setExtraStackFrame" --> (1192:30-1192:49) ".setExtraStackFrame" -(1890:50-1890:55) "(null" --> (1192:49-1192:54) "(null" -(1890:55-1891:5) ");\n " --> (1192:54-1193:4) ");\n\t\t\t" -(1891:5-1892:3) "}\n " --> (1193:4-1194:3) "\t}\n\t\t" -(1892:3-1893:1) "}\n" --> (1194:3-1195:2) "\t}\n\t" -(1893:1-1895:0) "}\n" --> (1195:2-1196:2) "\t}\n\t" -(1895:0-1895:9) "\nfunction" --> (1196:2-1196:11) "\tfunction" -(1895:9-1895:24) " checkPropTypes" --> (1196:11-1196:26) " checkPropTypes" -(1895:24-1895:35) "(typeSpecs," --> (1196:26-1196:37) "(typeSpecs," -(1895:35-1895:43) " values," --> (1196:37-1196:45) " values," -(1895:43-1895:53) " location," --> (1196:45-1196:55) " location," -(1895:53-1895:68) " componentName," --> (1196:55-1196:70) " componentName," -(1895:68-1895:77) " element)" --> (1196:70-1196:79) " element)" -(1895:77-1896:2) " {\n " --> (1196:79-1197:3) " {\n\t\t" -(1896:2-1898:4) " {\n // $FlowFixMe This is okay but Flow doesn't know it.\n " --> (1197:3-1198:4) "\t{\n\t\t\t" -(1898:4-1898:8) " var" --> (1198:4-1198:8) "\tvar" -(1898:8-1898:14) " has =" --> (1198:8-1198:14) " has =" -(1898:14-1898:23) " Function" --> (1198:14-1198:23) " Function" -(1898:23-1898:28) ".call" --> (1198:23-1198:28) ".call" -(1898:28-1898:33) ".bind" --> (1198:28-1198:33) ".bind" -(1898:33-1898:40) "(Object" --> (1198:33-1198:40) "(Object" -(1898:40-1898:50) ".prototype" --> (1198:40-1198:50) ".prototype" -(1898:50-1898:65) ".hasOwnProperty" --> (1198:50-1198:65) ".hasOwnProperty" -(1898:65-1900:4) ");\n\n " --> (1198:65-1199:0) ");" -(1900:4-1900:9) " for " --> (1199:0-1199:9) "\n\t\t\t\tfor " -(1900:9-1900:13) "(var" --> (1199:9-1199:13) "(var" -(1900:13-1900:29) " typeSpecName in" --> (1199:13-1199:29) " typeSpecName in" -(1900:29-1900:40) " typeSpecs)" --> (1199:29-1199:40) " typeSpecs)" -(1900:40-1901:6) " {\n " --> (1199:40-1200:0) " {" -(1901:6-1901:10) " if " --> (1200:0-1200:9) "\n\t\t\t\t\tif " -(1901:10-1901:14) "(has" --> (1200:9-1200:13) "(has" -(1901:14-1901:25) "(typeSpecs," --> (1200:13-1200:24) "(typeSpecs," -(1901:25-1901:38) " typeSpecName" --> (1200:24-1200:37) " typeSpecName" -(1901:38-1901:40) "))" --> (1200:37-1200:39) "))" -(1901:40-1902:8) " {\n " --> (1200:39-1201:6) " {\n\t\t\t\t\t" -(1902:8-1902:12) " var" --> (1201:6-1201:10) "\tvar" -(1902:12-1902:27) " error$1 = void" --> (1201:10-1201:25) " error$1 = void" -(1902:27-1906:8) " 0; // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n\n " --> (1201:25-1202:0) " 0;" -(1906:8-1906:12) " try" --> (1202:0-1202:10) "\n\t\t\t\t\t\ttry" -(1906:12-1909:10) " {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n " --> (1202:10-1203:0) " {" -(1909:10-1909:21) " if (typeof" --> (1203:0-1203:18) "\n\t\t\t\t\t\t\tif (typeof" -(1909:21-1909:31) " typeSpecs" --> (1203:18-1203:28) " typeSpecs" -(1909:31-1909:49) "[typeSpecName] !==" --> (1203:28-1203:46) "[typeSpecName] !==" -(1909:49-1909:61) " 'function')" --> (1203:46-1203:58) " \"function\")" -(1909:61-1910:12) " {\n " --> (1203:58-1204:8) " {\n\t\t\t\t\t\t\t" -(1910:12-1910:16) " var" --> (1204:8-1204:12) "\tvar" -(1910:16-1910:22) " err =" --> (1204:12-1204:18) " err =" -(1910:22-1910:29) " Error(" --> (1204:18-1204:25) " Error(" -(1910:29-1910:46) "(componentName ||" --> (1204:25-1204:42) "(componentName ||" -(1910:46-1910:63) " 'React class') +" --> (1204:42-1204:59) " \"React class\") +" -(1910:63-1910:70) " ': ' +" --> (1204:59-1204:66) " \": \" +" -(1910:70-1910:81) " location +" --> (1204:66-1204:77) " location +" -(1910:81-1910:93) " ' type `' +" --> (1204:77-1204:89) " \" type `\" +" -(1910:93-1910:108) " typeSpecName +" --> (1204:89-1204:104) " typeSpecName +" -(1910:108-1910:127) " '` is invalid; ' +" --> (1204:104-1204:123) " \"` is invalid; \" +" -(1910:127-1910:215) " 'it must be a function, usually from the `prop-types` package, but received `' + typeof" --> (1204:123-1204:211) " \"it must be a function, usually from the `prop-types` package, but received `\" + typeof" -(1910:215-1910:225) " typeSpecs" --> (1204:211-1204:221) " typeSpecs" -(1910:225-1910:241) "[typeSpecName] +" --> (1204:221-1204:237) "[typeSpecName] +" -(1910:241-1910:248) " '`.' +" --> (1204:237-1204:244) " \"`.\" +" -(1910:248-1910:344) " 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'" --> (1204:244-1204:340) " \"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.\"" -(1910:344-1911:12) ");\n " --> (1204:340-1205:0) ");" -(1911:12-1911:16) " err" --> (1205:0-1205:12) "\n\t\t\t\t\t\t\t\terr" -(1911:16-1911:23) ".name =" --> (1205:12-1205:19) ".name =" -(1911:23-1912:12) " 'Invariant Violation';\n " --> (1205:19-1206:0) " \"Invariant Violation\";" -(1912:12-1912:18) " throw" --> (1206:0-1206:14) "\n\t\t\t\t\t\t\t\tthrow" -(1912:18-1913:11) " err;\n " --> (1206:14-1207:7) " err;\n\t\t\t\t\t\t" -(1913:11-1915:10) "}\n\n " --> (1207:7-1208:0) "\t}" -(1915:10-1915:20) " error$1 =" --> (1208:0-1208:17) "\n\t\t\t\t\t\t\terror$1 =" -(1915:20-1915:30) " typeSpecs" --> (1208:17-1208:27) " typeSpecs" -(1915:30-1915:44) "[typeSpecName]" --> (1208:27-1208:41) "[typeSpecName]" -(1915:44-1915:52) "(values," --> (1208:41-1208:49) "(values," -(1915:52-1915:66) " typeSpecName," --> (1208:49-1208:63) " typeSpecName," -(1915:66-1915:81) " componentName," --> (1208:63-1208:78) " componentName," -(1915:81-1915:91) " location," --> (1208:78-1208:88) " location," -(1915:91-1915:97) " null," --> (1208:88-1208:94) " null," -(1915:97-1915:144) " 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'" --> (1208:94-1208:141) " \"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED\"" -(1915:144-1916:9) ");\n " --> (1208:141-1209:6) ");\n\t\t\t\t\t" -(1916:9-1916:17) "} catch " --> (1209:6-1209:15) "\t} catch " -(1916:17-1916:21) "(ex)" --> (1209:15-1209:19) "(ex)" -(1916:21-1917:10) " {\n " --> (1209:19-1210:0) " {" -(1917:10-1917:20) " error$1 =" --> (1210:0-1210:17) "\n\t\t\t\t\t\t\terror$1 =" -(1917:20-1918:9) " ex;\n " --> (1210:17-1211:6) " ex;\n\t\t\t\t\t" -(1918:9-1920:8) "}\n\n " --> (1211:6-1212:0) "\t}" -(1920:8-1920:12) " if " --> (1212:0-1212:10) "\n\t\t\t\t\t\tif " -(1920:12-1920:25) "(error$1 && !" --> (1212:10-1212:23) "(error$1 && !" -(1920:25-1920:44) "(error$1 instanceof" --> (1212:23-1212:42) "(error$1 instanceof" -(1920:44-1920:52) " Error))" --> (1212:42-1212:50) " Error))" -(1920:52-1921:10) " {\n " --> (1212:50-1213:0) " {" -(1921:10-1921:40) " setCurrentlyValidatingElement" --> (1213:0-1213:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" -(1921:40-1921:48) "(element" --> (1213:37-1213:45) "(element" -(1921:48-1923:10) ");\n\n " --> (1213:45-1214:0) ");" -(1923:10-1923:16) " error" --> (1214:0-1214:13) "\n\t\t\t\t\t\t\terror" -(1923:16-1923:49) "('%s: type specification of %s' +" --> (1214:13-1214:46) "(\"%s: type specification of %s\" +" -(1923:49-1923:89) " ' `%s` is invalid; the type checker ' +" --> (1214:46-1214:86) " \" `%s` is invalid; the type checker \" +" -(1923:89-1923:155) " 'function must return `null` or an `Error` but returned a %s. ' +" --> (1214:86-1214:152) " \"function must return `null` or an `Error` but returned a %s. \" +" -(1923:155-1923:223) " 'You may have forgotten to pass an argument to the type checker ' +" --> (1214:152-1214:220) " \"You may have forgotten to pass an argument to the type checker \" +" -(1923:223-1923:290) " 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +" --> (1214:220-1214:287) " \"creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and \" +" -(1923:290-1923:325) " 'shape all require an argument).'," --> (1214:287-1214:322) " \"shape all require an argument).\"," -(1923:325-1923:342) " componentName ||" --> (1214:322-1214:339) " componentName ||" -(1923:342-1923:357) " 'React class'," --> (1214:339-1214:354) " \"React class\"," -(1923:357-1923:367) " location," --> (1214:354-1214:364) " location," -(1923:367-1923:388) " typeSpecName, typeof" --> (1214:364-1214:385) " typeSpecName, typeof" -(1923:388-1923:396) " error$1" --> (1214:385-1214:393) " error$1" -(1923:396-1925:10) ");\n\n " --> (1214:393-1215:0) ");" -(1925:10-1925:40) " setCurrentlyValidatingElement" --> (1215:0-1215:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" -(1925:40-1925:45) "(null" --> (1215:37-1215:42) "(null" -(1925:45-1926:9) ");\n " --> (1215:42-1216:6) ");\n\t\t\t\t\t" -(1926:9-1928:8) "}\n\n " --> (1216:6-1217:0) "\t}" -(1928:8-1928:12) " if " --> (1217:0-1217:10) "\n\t\t\t\t\t\tif " -(1928:12-1928:31) "(error$1 instanceof" --> (1217:10-1217:29) "(error$1 instanceof" -(1928:31-1928:42) " Error && !" --> (1217:29-1217:40) " Error && !" -(1928:42-1928:50) "(error$1" --> (1217:40-1217:48) "(error$1" -(1928:50-1928:61) ".message in" --> (1217:48-1217:59) ".message in" -(1928:61-1928:82) " loggedTypeFailures))" --> (1217:59-1217:80) " loggedTypeFailures))" -(1928:82-1931:10) " {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n " --> (1217:80-1218:0) " {" -(1931:10-1931:29) " loggedTypeFailures" --> (1218:0-1218:26) "\n\t\t\t\t\t\t\tloggedTypeFailures" -(1931:29-1931:37) "[error$1" --> (1218:26-1218:34) "[error$1" -(1931:37-1931:48) ".message] =" --> (1218:34-1218:45) ".message] =" -(1931:48-1932:10) " true;\n " --> (1218:45-1219:0) " true;" -(1932:10-1932:40) " setCurrentlyValidatingElement" --> (1219:0-1219:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" -(1932:40-1932:48) "(element" --> (1219:37-1219:45) "(element" -(1932:48-1934:10) ");\n\n " --> (1219:45-1220:0) ");" -(1934:10-1934:16) " error" --> (1220:0-1220:13) "\n\t\t\t\t\t\t\terror" -(1934:16-1934:38) "('Failed %s type: %s'," --> (1220:13-1220:35) "(\"Failed %s type: %s\"," -(1934:38-1934:48) " location," --> (1220:35-1220:45) " location," -(1934:48-1934:56) " error$1" --> (1220:45-1220:53) " error$1" -(1934:56-1934:64) ".message" --> (1220:53-1220:61) ".message" -(1934:64-1936:10) ");\n\n " --> (1220:61-1221:0) ");" -(1936:10-1936:40) " setCurrentlyValidatingElement" --> (1221:0-1221:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" -(1936:40-1936:45) "(null" --> (1221:37-1221:42) "(null" -(1936:45-1937:9) ");\n " --> (1221:42-1222:6) ");\n\t\t\t\t\t" -(1937:9-1938:7) "}\n " --> (1222:6-1223:5) "\t}\n\t\t\t\t" -(1938:7-1939:5) "}\n " --> (1223:5-1224:4) "\t}\n\t\t\t" -(1939:5-1940:3) "}\n " --> (1224:4-1225:3) "\t}\n\t\t" -(1940:3-1941:1) "}\n" --> (1225:3-1226:2) "\t}\n\t" -(1941:1-1943:0) "}\n" --> (1226:2-1227:2) "\t}\n\t" -(1943:0-1943:9) "\nfunction" --> (1227:2-1227:11) "\tfunction" -(1943:9-1943:41) " setCurrentlyValidatingElement$1" --> (1227:11-1227:43) " setCurrentlyValidatingElement$1" -(1943:41-1943:50) "(element)" --> (1227:43-1227:52) "(element)" -(1943:50-1944:2) " {\n " --> (1227:52-1228:3) " {\n\t\t" -(1944:2-1945:4) " {\n " --> (1228:3-1229:0) "\t{" -(1945:4-1945:8) " if " --> (1229:0-1229:8) "\n\t\t\t\tif " -(1945:8-1945:17) "(element)" --> (1229:8-1229:17) "(element)" -(1945:17-1946:6) " {\n " --> (1229:17-1230:5) " {\n\t\t\t\t" -(1946:6-1946:10) " var" --> (1230:5-1230:9) "\tvar" -(1946:10-1946:18) " owner =" --> (1230:9-1230:17) " owner =" -(1946:18-1946:26) " element" --> (1230:17-1230:25) " element" -(1946:26-1947:6) "._owner;\n " --> (1230:25-1231:5) "._owner;\n\t\t\t\t" -(1947:6-1947:10) " var" --> (1231:5-1231:9) "\tvar" -(1947:10-1947:18) " stack =" --> (1231:9-1231:17) " stack =" -(1947:18-1947:55) " describeUnknownElementTypeFrameInDEV" --> (1231:17-1231:54) " describeUnknownElementTypeFrameInDEV" -(1947:55-1947:63) "(element" --> (1231:54-1231:62) "(element" -(1947:63-1947:69) ".type," --> (1231:62-1231:68) ".type," -(1947:69-1947:77) " element" --> (1231:68-1231:76) " element" -(1947:77-1947:86) "._source," --> (1231:76-1231:85) "._source," -(1947:86-1947:94) " owner ?" --> (1231:85-1231:93) " owner ?" -(1947:94-1947:100) " owner" --> (1231:93-1231:99) " owner" -(1947:100-1947:107) ".type :" --> (1231:99-1231:106) ".type :" -(1947:107-1947:112) " null" --> (1231:106-1231:111) " null" -(1947:112-1948:6) ");\n " --> (1231:111-1232:0) ");" -(1948:6-1948:25) " setExtraStackFrame" --> (1232:0-1232:24) "\n\t\t\t\t\tsetExtraStackFrame" -(1948:25-1948:31) "(stack" --> (1232:24-1232:30) "(stack" -(1948:31-1949:5) ");\n " --> (1232:30-1233:4) ");\n\t\t\t" -(1949:5-1949:11) "} else" --> (1233:4-1233:11) "\t} else" -(1949:11-1950:6) " {\n " --> (1233:11-1234:0) " {" -(1950:6-1950:25) " setExtraStackFrame" --> (1234:0-1234:24) "\n\t\t\t\t\tsetExtraStackFrame" -(1950:25-1950:30) "(null" --> (1234:24-1234:29) "(null" -(1950:30-1951:5) ");\n " --> (1234:29-1235:4) ");\n\t\t\t" -(1951:5-1952:3) "}\n " --> (1235:4-1236:3) "\t}\n\t\t" -(1952:3-1953:1) "}\n" --> (1236:3-1237:2) "\t}\n\t" -(1953:1-1955:0) "}\n" --> (1237:2-1238:2) "\t}\n\t" -(1955:0-1955:4) "\nvar" --> (1238:2-1238:6) "\tvar" -(1955:4-1957:0) " propTypesMisspellWarningShown;\n" --> (1238:6-1239:2) " propTypesMisspellWarningShown;\n\t" -(1957:0-1958:2) "\n{\n " --> (1239:2-1240:0) "\t{" -(1958:2-1958:34) " propTypesMisspellWarningShown =" --> (1240:0-1240:35) "\n\t\t\tpropTypesMisspellWarningShown =" -(1958:34-1959:1) " false;\n" --> (1240:35-1241:2) " false;\n\t" -(1959:1-1961:0) "}\n" --> (1241:2-1242:2) "\t}\n\t" -(1961:0-1961:9) "\nfunction" --> (1242:2-1242:11) "\tfunction" -(1961:9-1961:39) " getDeclarationErrorAddendum()" --> (1242:11-1242:41) " getDeclarationErrorAddendum()" -(1961:39-1962:2) " {\n " --> (1242:41-1243:0) " {" -(1962:2-1962:6) " if " --> (1243:0-1243:7) "\n\t\t\tif " -(1962:6-1962:24) "(ReactCurrentOwner" --> (1243:7-1243:25) "(ReactCurrentOwner" -(1962:24-1962:33) ".current)" --> (1243:25-1243:34) ".current)" -(1962:33-1963:4) " {\n " --> (1243:34-1244:4) " {\n\t\t\t" -(1963:4-1963:8) " var" --> (1244:4-1244:8) "\tvar" -(1963:8-1963:15) " name =" --> (1244:8-1244:15) " name =" -(1963:15-1963:32) " getComponentName" --> (1244:15-1244:32) " getComponentName" -(1963:32-1963:50) "(ReactCurrentOwner" --> (1244:32-1244:50) "(ReactCurrentOwner" -(1963:50-1963:58) ".current" --> (1244:50-1244:58) ".current" -(1963:58-1963:63) ".type" --> (1244:58-1244:63) ".type" -(1963:63-1965:4) ");\n\n " --> (1244:63-1245:0) ");" -(1965:4-1965:8) " if " --> (1245:0-1245:8) "\n\t\t\t\tif " -(1965:8-1965:14) "(name)" --> (1245:8-1245:14) "(name)" -(1965:14-1966:6) " {\n " --> (1245:14-1246:0) " {" -(1966:6-1966:13) " return" --> (1246:0-1246:12) "\n\t\t\t\t\treturn" -(1966:13-1966:50) " '\\n\\nCheck the render method of `' +" --> (1246:12-1246:49) " \"\\n\\nCheck the render method of `\" +" -(1966:50-1966:57) " name +" --> (1246:49-1246:56) " name +" -(1966:57-1967:5) " '`.';\n " --> (1246:56-1247:4) " \"`.\";\n\t\t\t" -(1967:5-1968:3) "}\n " --> (1247:4-1248:3) "\t}\n\t\t" -(1968:3-1970:2) "}\n\n " --> (1248:3-1249:0) "\t}" -(1970:2-1970:9) " return" --> (1249:0-1249:10) "\n\t\t\treturn" -(1970:9-1971:1) " '';\n" --> (1249:10-1250:2) " \"\";\n\t" -(1971:1-1973:0) "}\n" --> (1250:2-1251:2) "\t}\n\t" -(1973:0-1973:9) "\nfunction" --> (1251:2-1251:11) "\tfunction" -(1973:9-1973:36) " getSourceInfoErrorAddendum" --> (1251:11-1251:38) " getSourceInfoErrorAddendum" -(1973:36-1973:44) "(source)" --> (1251:38-1251:46) "(source)" -(1973:44-1974:2) " {\n " --> (1251:46-1252:0) " {" -(1974:2-1974:6) " if " --> (1252:0-1252:7) "\n\t\t\tif " -(1974:6-1974:17) "(source !==" --> (1252:7-1252:18) "(source !==" -(1974:17-1974:28) " undefined)" --> (1252:18-1252:29) " undefined)" -(1974:28-1975:4) " {\n " --> (1252:29-1253:4) " {\n\t\t\t" -(1975:4-1975:8) " var" --> (1253:4-1253:8) "\tvar" -(1975:8-1975:19) " fileName =" --> (1253:8-1253:19) " fileName =" -(1975:19-1975:26) " source" --> (1253:19-1253:26) " source" -(1975:26-1975:35) ".fileName" --> (1253:26-1253:35) ".fileName" -(1975:35-1975:43) ".replace" --> (1253:35-1253:43) ".replace" -(1975:43-1975:56) "(/^.*[\\\\\\/]/," --> (1253:43-1253:56) "(/^.*[\\\\\\/]/," -(1975:56-1975:59) " ''" --> (1253:56-1253:59) " \"\"" -(1975:59-1976:4) ");\n " --> (1253:59-1254:4) ");\n\t\t\t" -(1976:4-1976:8) " var" --> (1254:4-1254:8) "\tvar" -(1976:8-1976:21) " lineNumber =" --> (1254:8-1254:21) " lineNumber =" -(1976:21-1976:28) " source" --> (1254:21-1254:28) " source" -(1976:28-1977:4) ".lineNumber;\n " --> (1254:28-1255:0) ".lineNumber;" -(1977:4-1977:11) " return" --> (1255:0-1255:11) "\n\t\t\t\treturn" -(1977:11-1977:39) " '\\n\\nCheck your code at ' +" --> (1255:11-1255:39) " \"\\n\\nCheck your code at \" +" -(1977:39-1977:50) " fileName +" --> (1255:39-1255:50) " fileName +" -(1977:50-1977:56) " ':' +" --> (1255:50-1255:56) " \":\" +" -(1977:56-1977:69) " lineNumber +" --> (1255:56-1255:69) " lineNumber +" -(1977:69-1978:3) " '.';\n " --> (1255:69-1256:3) " \".\";\n\t\t" -(1978:3-1980:2) "}\n\n " --> (1256:3-1257:0) "\t}" -(1980:2-1980:9) " return" --> (1257:0-1257:10) "\n\t\t\treturn" -(1980:9-1981:1) " '';\n" --> (1257:10-1258:2) " \"\";\n\t" -(1981:1-1983:0) "}\n" --> (1258:2-1259:2) "\t}\n\t" -(1983:0-1983:9) "\nfunction" --> (1259:2-1259:11) "\tfunction" -(1983:9-1983:44) " getSourceInfoErrorAddendumForProps" --> (1259:11-1259:46) " getSourceInfoErrorAddendumForProps" -(1983:44-1983:58) "(elementProps)" --> (1259:46-1259:60) "(elementProps)" -(1983:58-1984:2) " {\n " --> (1259:60-1260:0) " {" -(1984:2-1984:6) " if " --> (1260:0-1260:7) "\n\t\t\tif " -(1984:6-1984:23) "(elementProps !==" --> (1260:7-1260:24) "(elementProps !==" -(1984:23-1984:31) " null &&" --> (1260:24-1260:32) " null &&" -(1984:31-1984:48) " elementProps !==" --> (1260:32-1260:49) " elementProps !==" -(1984:48-1984:59) " undefined)" --> (1260:49-1260:60) " undefined)" -(1984:59-1985:4) " {\n " --> (1260:60-1261:0) " {" -(1985:4-1985:11) " return" --> (1261:0-1261:11) "\n\t\t\t\treturn" -(1985:11-1985:38) " getSourceInfoErrorAddendum" --> (1261:11-1261:38) " getSourceInfoErrorAddendum" -(1985:38-1985:51) "(elementProps" --> (1261:38-1261:51) "(elementProps" -(1985:51-1985:60) ".__source" --> (1261:51-1261:60) ".__source" -(1985:60-1986:3) ");\n " --> (1261:60-1262:3) ");\n\t\t" -(1986:3-1988:2) "}\n\n " --> (1262:3-1263:0) "\t}" -(1988:2-1988:9) " return" --> (1263:0-1263:10) "\n\t\t\treturn" -(1988:9-1989:1) " '';\n" --> (1263:10-1264:2) " \"\";\n\t" -(1989:1-1997:0) "}\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\n\n" --> (1264:2-1265:2) "\t}\n\t" -(1997:0-1997:4) "\nvar" --> (1265:2-1265:6) "\tvar" -(1997:4-1997:28) " ownerHasKeyUseWarning =" --> (1265:6-1265:30) " ownerHasKeyUseWarning =" -(1997:28-1997:30) " {" --> (1265:30-1265:31) " " -(1997:30-1999:0) "};\n" --> (1265:31-1266:2) "{};\n\t" -(1999:0-1999:9) "\nfunction" --> (1266:2-1266:11) "\tfunction" -(1999:9-1999:38) " getCurrentComponentErrorInfo" --> (1266:11-1266:40) " getCurrentComponentErrorInfo" -(1999:38-1999:50) "(parentType)" --> (1266:40-1266:52) "(parentType)" -(1999:50-2000:2) " {\n " --> (1266:52-1267:3) " {\n\t\t" -(2000:2-2000:6) " var" --> (1267:3-1267:7) "\tvar" -(2000:6-2000:13) " info =" --> (1267:7-1267:14) " info =" -(2000:13-2000:42) " getDeclarationErrorAddendum(" --> (1267:14-1267:43) " getDeclarationErrorAddendum(" -(2000:42-2002:2) ");\n\n " --> (1267:43-1268:0) ");" -(2002:2-2002:7) " if (" --> (1268:0-1268:8) "\n\t\t\tif (" -(2002:7-2002:13) "!info)" --> (1268:8-1268:14) "!info)" -(2002:13-2003:4) " {\n " --> (1268:14-1269:4) " {\n\t\t\t" -(2003:4-2003:8) " var" --> (1269:4-1269:8) "\tvar" -(2003:8-2003:28) " parentName = typeof" --> (1269:8-1269:28) " parentName = typeof" -(2003:28-2003:43) " parentType ===" --> (1269:28-1269:43) " parentType ===" -(2003:43-2003:54) " 'string' ?" --> (1269:43-1269:54) " \"string\" ?" -(2003:54-2003:67) " parentType :" --> (1269:54-1269:67) " parentType :" -(2003:67-2003:78) " parentType" --> (1269:67-1269:78) " parentType" -(2003:78-2003:93) ".displayName ||" --> (1269:78-1269:93) ".displayName ||" -(2003:93-2003:104) " parentType" --> (1269:93-1269:104) " parentType" -(2003:104-2005:4) ".name;\n\n " --> (1269:104-1270:0) ".name;" -(2005:4-2005:8) " if " --> (1270:0-1270:8) "\n\t\t\t\tif " -(2005:8-2005:20) "(parentName)" --> (1270:8-1270:20) "(parentName)" -(2005:20-2006:6) " {\n " --> (1270:20-1271:0) " {" -(2006:6-2006:13) " info =" --> (1271:0-1271:12) "\n\t\t\t\t\tinfo =" -(2006:13-2006:61) " \"\\n\\nCheck the top-level render call using <\" +" --> (1271:12-1271:60) " \"\\n\\nCheck the top-level render call using <\" +" -(2006:61-2006:74) " parentName +" --> (1271:60-1271:73) " parentName +" -(2006:74-2007:5) " \">.\";\n " --> (1271:73-1272:4) " \">.\";\n\t\t\t" -(2007:5-2008:3) "}\n " --> (1272:4-1273:3) "\t}\n\t\t" -(2008:3-2010:2) "}\n\n " --> (1273:3-1274:0) "\t}" -(2010:2-2010:9) " return" --> (1274:0-1274:10) "\n\t\t\treturn" -(2010:9-2011:1) " info;\n" --> (1274:10-1275:2) " info;\n\t" -(2011:1-2025:0) "}\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it. Error statuses are cached so a warning\n * will only be shown once.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\n\n" --> (1275:2-1276:2) "\t}\n\t" -(2025:0-2025:9) "\nfunction" --> (1276:2-1276:11) "\tfunction" -(2025:9-2025:29) " validateExplicitKey" --> (1276:11-1276:31) " validateExplicitKey" -(2025:29-2025:38) "(element," --> (1276:31-1276:40) "(element," -(2025:38-2025:50) " parentType)" --> (1276:40-1276:52) " parentType)" -(2025:50-2026:2) " {\n " --> (1276:52-1277:0) " {" -(2026:2-2026:7) " if (" --> (1277:0-1277:8) "\n\t\t\tif (" -(2026:7-2026:15) "!element" --> (1277:8-1277:16) "!element" -(2026:15-2026:25) "._store ||" --> (1277:16-1277:26) "._store ||" -(2026:25-2026:33) " element" --> (1277:26-1277:34) " element" -(2026:33-2026:40) "._store" --> (1277:34-1277:41) "._store" -(2026:40-2026:53) ".validated ||" --> (1277:41-1277:54) ".validated ||" -(2026:53-2026:61) " element" --> (1277:54-1277:62) " element" -(2026:61-2026:68) ".key !=" --> (1277:62-1277:69) ".key !=" -(2026:68-2026:74) " null)" --> (1277:69-1277:75) " null)" -(2026:74-2027:4) " {\n " --> (1277:75-1278:0) " {" -(2027:4-2028:3) " return;\n " --> (1278:0-1279:3) "\n\t\t\t\treturn;\n\t\t" -(2028:3-2030:2) "}\n\n " --> (1279:3-1280:0) "\t}" -(2030:2-2030:10) " element" --> (1280:0-1280:11) "\n\t\t\telement" -(2030:10-2030:17) "._store" --> (1280:11-1280:18) "._store" -(2030:17-2030:29) ".validated =" --> (1280:18-1280:30) ".validated =" -(2030:29-2031:2) " true;\n " --> (1280:30-1281:3) " true;\n\t\t" -(2031:2-2031:6) " var" --> (1281:3-1281:7) "\tvar" -(2031:6-2031:34) " currentComponentErrorInfo =" --> (1281:7-1281:35) " currentComponentErrorInfo =" -(2031:34-2031:63) " getCurrentComponentErrorInfo" --> (1281:35-1281:64) " getCurrentComponentErrorInfo" -(2031:63-2031:74) "(parentType" --> (1281:64-1281:75) "(parentType" -(2031:74-2033:2) ");\n\n " --> (1281:75-1282:0) ");" -(2033:2-2033:6) " if " --> (1282:0-1282:7) "\n\t\t\tif " -(2033:6-2033:28) "(ownerHasKeyUseWarning" --> (1282:7-1282:29) "(ownerHasKeyUseWarning" -(2033:28-2033:56) "[currentComponentErrorInfo])" --> (1282:29-1282:57) "[currentComponentErrorInfo])" -(2033:56-2034:4) " {\n " --> (1282:57-1283:0) " {" -(2034:4-2035:3) " return;\n " --> (1283:0-1284:3) "\n\t\t\t\treturn;\n\t\t" -(2035:3-2037:2) "}\n\n " --> (1284:3-1285:0) "\t}" -(2037:2-2037:24) " ownerHasKeyUseWarning" --> (1285:0-1285:25) "\n\t\t\townerHasKeyUseWarning" -(2037:24-2037:53) "[currentComponentErrorInfo] =" --> (1285:25-1285:54) "[currentComponentErrorInfo] =" -(2037:53-2041:2) " true; // Usually the current owner is the offender, but if it accepts children as a\n // property, it may be the creator of the child that's responsible for\n // assigning it a key.\n\n " --> (1285:54-1286:3) " true;\n\t\t" -(2041:2-2041:6) " var" --> (1286:3-1286:7) "\tvar" -(2041:6-2041:19) " childOwner =" --> (1286:7-1286:20) " childOwner =" -(2041:19-2043:2) " '';\n\n " --> (1286:20-1287:0) " \"\";" -(2043:2-2043:6) " if " --> (1287:0-1287:7) "\n\t\t\tif " -(2043:6-2043:17) "(element &&" --> (1287:7-1287:18) "(element &&" -(2043:17-2043:25) " element" --> (1287:18-1287:26) " element" -(2043:25-2043:35) "._owner &&" --> (1287:26-1287:36) "._owner &&" -(2043:35-2043:43) " element" --> (1287:36-1287:44) " element" -(2043:43-2043:54) "._owner !==" --> (1287:44-1287:55) "._owner !==" -(2043:54-2043:72) " ReactCurrentOwner" --> (1287:55-1287:73) " ReactCurrentOwner" -(2043:72-2043:81) ".current)" --> (1287:73-1287:82) ".current)" -(2043:81-2045:4) " {\n // Give the component that originally created this child.\n " --> (1287:82-1288:0) " {" -(2045:4-2045:17) " childOwner =" --> (1288:0-1288:17) "\n\t\t\t\tchildOwner =" -(2045:17-2045:50) " \" It was passed a child from \" +" --> (1288:17-1288:50) " \" It was passed a child from \" +" -(2045:50-2045:67) " getComponentName" --> (1288:50-1288:67) " getComponentName" -(2045:67-2045:75) "(element" --> (1288:67-1288:75) "(element" -(2045:75-2045:82) "._owner" --> (1288:75-1288:82) "._owner" -(2045:82-2045:87) ".type" --> (1288:82-1288:87) ".type" -(2045:87-2045:90) ") +" --> (1288:87-1288:90) ") +" -(2045:90-2046:3) " \".\";\n " --> (1288:90-1289:3) " \".\";\n\t\t" -(2046:3-2048:2) "}\n\n " --> (1289:3-1290:3) "\t}\n\t\t" -(2048:2-2049:4) " {\n " --> (1290:3-1291:0) "\t{" -(2049:4-2049:36) " setCurrentlyValidatingElement$1" --> (1291:0-1291:36) "\n\t\t\t\tsetCurrentlyValidatingElement$1" -(2049:36-2049:44) "(element" --> (1291:36-1291:44) "(element" -(2049:44-2051:4) ");\n\n " --> (1291:44-1292:0) ");" -(2051:4-2051:10) " error" --> (1292:0-1292:10) "\n\t\t\t\terror" -(2051:10-2051:68) "('Each child in a list should have a unique \"key\" prop.' +" --> (1292:10-1292:70) "(\"Each child in a list should have a unique \\\"key\\\" prop.\" +" -(2051:68-2051:140) " '%s%s See https://reactjs.org/link/warning-keys for more information.'," --> (1292:70-1292:142) " \"%s%s See https://reactjs.org/link/warning-keys for more information.\"," -(2051:140-2051:167) " currentComponentErrorInfo," --> (1292:142-1292:169) " currentComponentErrorInfo," -(2051:167-2051:178) " childOwner" --> (1292:169-1292:180) " childOwner" -(2051:178-2053:4) ");\n\n " --> (1292:180-1293:0) ");" -(2053:4-2053:36) " setCurrentlyValidatingElement$1" --> (1293:0-1293:36) "\n\t\t\t\tsetCurrentlyValidatingElement$1" -(2053:36-2053:41) "(null" --> (1293:36-1293:41) "(null" -(2053:41-2054:3) ");\n " --> (1293:41-1294:3) ");\n\t\t" -(2054:3-2055:1) "}\n" --> (1294:3-1295:2) "\t}\n\t" -(2055:1-2067:0) "}\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\n\n" --> (1295:2-1296:2) "\t}\n\t" -(2067:0-2067:9) "\nfunction" --> (1296:2-1296:11) "\tfunction" -(2067:9-2067:27) " validateChildKeys" --> (1296:11-1296:29) " validateChildKeys" -(2067:27-2067:33) "(node," --> (1296:29-1296:35) "(node," -(2067:33-2067:45) " parentType)" --> (1296:35-1296:47) " parentType)" -(2067:45-2068:2) " {\n " --> (1296:47-1297:0) " {" -(2068:2-2068:13) " if (typeof" --> (1297:0-1297:14) "\n\t\t\tif (typeof" -(2068:13-2068:22) " node !==" --> (1297:14-1297:23) " node !==" -(2068:22-2068:32) " 'object')" --> (1297:23-1297:33) " \"object\")" -(2068:32-2069:4) " {\n " --> (1297:33-1298:0) " {" -(2069:4-2070:3) " return;\n " --> (1298:0-1299:3) "\n\t\t\t\treturn;\n\t\t" -(2070:3-2072:2) "}\n\n " --> (1299:3-1300:0) "\t}" -(2072:2-2072:6) " if " --> (1300:0-1300:7) "\n\t\t\tif " -(2072:6-2072:12) "(Array" --> (1300:7-1300:13) "(Array" -(2072:12-2072:20) ".isArray" --> (1300:13-1300:21) ".isArray" -(2072:20-2072:25) "(node" --> (1300:21-1300:26) "(node" -(2072:25-2072:27) "))" --> (1300:26-1300:28) "))" -(2072:27-2073:4) " {\n " --> (1300:28-1301:0) " {" -(2073:4-2073:9) " for " --> (1301:0-1301:9) "\n\t\t\t\tfor " -(2073:9-2073:13) "(var" --> (1301:9-1301:13) "(var" -(2073:13-2073:17) " i =" --> (1301:13-1301:17) " i =" -(2073:17-2073:20) " 0;" --> (1301:17-1301:20) " 0;" -(2073:20-2073:24) " i <" --> (1301:20-1301:24) " i <" -(2073:24-2073:29) " node" --> (1301:24-1301:29) " node" -(2073:29-2073:37) ".length;" --> (1301:29-1301:37) ".length;" -(2073:37-2073:42) " i++)" --> (1301:37-1301:42) " i++)" -(2073:42-2074:6) " {\n " --> (1301:42-1302:5) " {\n\t\t\t\t" -(2074:6-2074:10) " var" --> (1302:5-1302:9) "\tvar" -(2074:10-2074:18) " child =" --> (1302:9-1302:17) " child =" -(2074:18-2074:23) " node" --> (1302:17-1302:22) " node" -(2074:23-2076:6) "[i];\n\n " --> (1302:22-1303:0) "[i];" -(2076:6-2076:10) " if " --> (1303:0-1303:9) "\n\t\t\t\t\tif " -(2076:10-2076:25) "(isValidElement" --> (1303:9-1303:24) "(isValidElement" -(2076:25-2076:31) "(child" --> (1303:24-1303:30) "(child" -(2076:31-2076:33) "))" --> (1303:30-1303:32) "))" -(2076:33-2077:8) " {\n " --> (1303:32-1304:0) " {" -(2077:8-2077:28) " validateExplicitKey" --> (1304:0-1304:26) "\n\t\t\t\t\t\tvalidateExplicitKey" -(2077:28-2077:35) "(child," --> (1304:26-1304:33) "(child," -(2077:35-2077:46) " parentType" --> (1304:33-1304:44) " parentType" -(2077:46-2078:7) ");\n " --> (1304:44-1305:5) ");\n\t\t\t\t" -(2078:7-2079:5) "}\n " --> (1305:5-1306:4) "\t}\n\t\t\t" -(2079:5-2080:3) "}\n " --> (1306:4-1307:3) "\t}\n\t\t" -(2080:3-2080:13) "} else if " --> (1307:3-1307:14) "\t} else if " -(2080:13-2080:28) "(isValidElement" --> (1307:14-1307:29) "(isValidElement" -(2080:28-2080:33) "(node" --> (1307:29-1307:34) "(node" -(2080:33-2080:35) "))" --> (1307:34-1307:36) "))" -(2080:35-2082:4) " {\n // This element was passed in a valid location.\n " --> (1307:36-1308:0) " {" -(2082:4-2082:8) " if " --> (1308:0-1308:8) "\n\t\t\t\tif " -(2082:8-2082:13) "(node" --> (1308:8-1308:13) "(node" -(2082:13-2082:21) "._store)" --> (1308:13-1308:21) "._store)" -(2082:21-2083:6) " {\n " --> (1308:21-1309:0) " {" -(2083:6-2083:11) " node" --> (1309:0-1309:10) "\n\t\t\t\t\tnode" -(2083:11-2083:18) "._store" --> (1309:10-1309:17) "._store" -(2083:18-2083:30) ".validated =" --> (1309:17-1309:29) ".validated =" -(2083:30-2084:5) " true;\n " --> (1309:29-1310:4) " true;\n\t\t\t" -(2084:5-2085:3) "}\n " --> (1310:4-1311:3) "\t}\n\t\t" -(2085:3-2085:13) "} else if " --> (1311:3-1311:14) "\t} else if " -(2085:13-2085:19) "(node)" --> (1311:14-1311:20) "(node)" -(2085:19-2086:4) " {\n " --> (1311:20-1312:4) " {\n\t\t\t" -(2086:4-2086:8) " var" --> (1312:4-1312:8) "\tvar" -(2086:8-2086:21) " iteratorFn =" --> (1312:8-1312:21) " iteratorFn =" -(2086:21-2086:35) " getIteratorFn" --> (1312:21-1312:35) " getIteratorFn" -(2086:35-2086:40) "(node" --> (1312:35-1312:40) "(node" -(2086:40-2088:4) ");\n\n " --> (1312:40-1313:0) ");" -(2088:4-2088:15) " if (typeof" --> (1313:0-1313:15) "\n\t\t\t\tif (typeof" -(2088:15-2088:30) " iteratorFn ===" --> (1313:15-1313:30) " iteratorFn ===" -(2088:30-2088:42) " 'function')" --> (1313:30-1313:42) " \"function\")" -(2088:42-2091:6) " {\n // Entry iterators used to provide implicit keys,\n // but now we print a separate warning for them later.\n " --> (1313:42-1314:0) " {" -(2091:6-2091:10) " if " --> (1314:0-1314:9) "\n\t\t\t\t\tif " -(2091:10-2091:25) "(iteratorFn !==" --> (1314:9-1314:24) "(iteratorFn !==" -(2091:25-2091:30) " node" --> (1314:24-1314:29) " node" -(2091:30-2091:39) ".entries)" --> (1314:29-1314:38) ".entries)" -(2091:39-2092:8) " {\n " --> (1314:38-1315:6) " {\n\t\t\t\t\t" -(2092:8-2092:12) " var" --> (1315:6-1315:10) "\tvar" -(2092:12-2092:23) " iterator =" --> (1315:10-1315:21) " iterator =" -(2092:23-2092:34) " iteratorFn" --> (1315:21-1315:32) " iteratorFn" -(2092:34-2092:39) ".call" --> (1315:32-1315:37) ".call" -(2092:39-2092:44) "(node" --> (1315:37-1315:42) "(node" -(2092:44-2093:8) ");\n " --> (1315:42-1316:6) ");\n\t\t\t\t\t" -(2093:8-2093:12) " var" --> (1316:6-1316:10) "\tvar" -(2093:12-2095:8) " step;\n\n " --> (1316:10-1317:0) " step;" -(2095:8-2095:17) " while (!" --> (1317:0-1317:15) "\n\t\t\t\t\t\twhile (!" -(2095:17-2095:24) "(step =" --> (1317:15-1317:22) "(step =" -(2095:24-2095:33) " iterator" --> (1317:22-1317:31) " iterator" -(2095:33-2095:39) ".next(" --> (1317:31-1317:37) ".next(" -(2095:39-2095:41) "))" --> (1317:37-1317:39) "))" -(2095:41-2095:47) ".done)" --> (1317:39-1317:45) ".done)" -(2095:47-2096:10) " {\n " --> (1317:45-1318:0) " {" -(2096:10-2096:14) " if " --> (1318:0-1318:11) "\n\t\t\t\t\t\t\tif " -(2096:14-2096:29) "(isValidElement" --> (1318:11-1318:26) "(isValidElement" -(2096:29-2096:34) "(step" --> (1318:26-1318:31) "(step" -(2096:34-2096:40) ".value" --> (1318:31-1318:37) ".value" -(2096:40-2096:42) "))" --> (1318:37-1318:39) "))" -(2096:42-2097:12) " {\n " --> (1318:39-1319:0) " {" -(2097:12-2097:32) " validateExplicitKey" --> (1319:0-1319:28) "\n\t\t\t\t\t\t\t\tvalidateExplicitKey" -(2097:32-2097:37) "(step" --> (1319:28-1319:33) "(step" -(2097:37-2097:44) ".value," --> (1319:33-1319:40) ".value," -(2097:44-2097:55) " parentType" --> (1319:40-1319:51) " parentType" -(2097:55-2098:11) ");\n " --> (1319:51-1320:7) ");\n\t\t\t\t\t\t" -(2098:11-2099:9) "}\n " --> (1320:7-1321:6) "\t}\n\t\t\t\t\t" -(2099:9-2100:7) "}\n " --> (1321:6-1322:5) "\t}\n\t\t\t\t" -(2100:7-2101:5) "}\n " --> (1322:5-1323:4) "\t}\n\t\t\t" -(2101:5-2102:3) "}\n " --> (1323:4-1324:3) "\t}\n\t\t" -(2102:3-2103:1) "}\n" --> (1324:3-1325:2) "\t}\n\t" -(2103:1-2112:0) "}\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\n\n" --> (1325:2-1326:2) "\t}\n\t" -(2112:0-2112:9) "\nfunction" --> (1326:2-1326:11) "\tfunction" -(2112:9-2112:27) " validatePropTypes" --> (1326:11-1326:29) " validatePropTypes" -(2112:27-2112:36) "(element)" --> (1326:29-1326:38) "(element)" -(2112:36-2113:2) " {\n " --> (1326:38-1327:3) " {\n\t\t" -(2113:2-2114:4) " {\n " --> (1327:3-1328:4) "\t{\n\t\t\t" -(2114:4-2114:8) " var" --> (1328:4-1328:8) "\tvar" -(2114:8-2114:15) " type =" --> (1328:8-1328:15) " type =" -(2114:15-2114:23) " element" --> (1328:15-1328:23) " element" -(2114:23-2116:4) ".type;\n\n " --> (1328:23-1329:0) ".type;" -(2116:4-2116:8) " if " --> (1329:0-1329:8) "\n\t\t\t\tif " -(2116:8-2116:17) "(type ===" --> (1329:8-1329:17) "(type ===" -(2116:17-2116:25) " null ||" --> (1329:17-1329:25) " null ||" -(2116:25-2116:34) " type ===" --> (1329:25-1329:34) " type ===" -(2116:34-2116:54) " undefined || typeof" --> (1329:34-1329:54) " undefined || typeof" -(2116:54-2116:63) " type ===" --> (1329:54-1329:63) " type ===" -(2116:63-2116:73) " 'string')" --> (1329:63-1329:73) " \"string\")" -(2116:73-2117:6) " {\n " --> (1329:73-1330:0) " {" -(2117:6-2118:5) " return;\n " --> (1330:0-1331:4) "\n\t\t\t\t\treturn;\n\t\t\t" -(2118:5-2120:4) "}\n\n " --> (1331:4-1332:4) "\t}\n\t\t\t" -(2120:4-2120:8) " var" --> (1332:4-1332:8) "\tvar" -(2120:8-2122:4) " propTypes;\n\n " --> (1332:8-1333:0) " propTypes;" -(2122:4-2122:15) " if (typeof" --> (1333:0-1333:15) "\n\t\t\t\tif (typeof" -(2122:15-2122:24) " type ===" --> (1333:15-1333:24) " type ===" -(2122:24-2122:36) " 'function')" --> (1333:24-1333:36) " \"function\")" -(2122:36-2123:6) " {\n " --> (1333:36-1334:0) " {" -(2123:6-2123:18) " propTypes =" --> (1334:0-1334:17) "\n\t\t\t\t\tpropTypes =" -(2123:18-2123:23) " type" --> (1334:17-1334:22) " type" -(2123:23-2124:5) ".propTypes;\n " --> (1334:22-1335:4) ".propTypes;\n\t\t\t" -(2124:5-2124:22) "} else if (typeof" --> (1335:4-1335:22) "\t} else if (typeof" -(2124:22-2124:31) " type ===" --> (1335:22-1335:31) " type ===" -(2124:31-2124:44) " 'object' && " --> (1335:31-1335:44) " \"object\" && " -(2124:44-2124:49) "(type" --> (1335:44-1335:49) "(type" -(2124:49-2124:62) ".$$typeof ===" --> (1335:49-1335:62) ".$$typeof ===" -(2124:62-2126:4) " REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.\n // Inner props are checked in the reconciler.\n " --> (1335:62-1335:88) " REACT_FORWARD_REF_TYPE ||" -(2126:4-2126:9) " type" --> (1335:88-1335:93) " type" -(2126:9-2126:22) ".$$typeof ===" --> (1335:93-1335:106) ".$$typeof ===" -(2126:22-2126:40) " REACT_MEMO_TYPE))" --> (1335:106-1335:124) " REACT_MEMO_TYPE))" -(2126:40-2127:6) " {\n " --> (1335:124-1336:0) " {" -(2127:6-2127:18) " propTypes =" --> (1336:0-1336:17) "\n\t\t\t\t\tpropTypes =" -(2127:18-2127:23) " type" --> (1336:17-1336:22) " type" -(2127:23-2128:5) ".propTypes;\n " --> (1336:22-1337:4) ".propTypes;\n\t\t\t" -(2128:5-2128:11) "} else" --> (1337:4-1337:11) "\t} else" -(2128:11-2129:6) " {\n " --> (1337:11-1338:0) " {" -(2129:6-2130:5) " return;\n " --> (1338:0-1339:4) "\n\t\t\t\t\treturn;\n\t\t\t" -(2130:5-2132:4) "}\n\n " --> (1339:4-1340:0) "\t}" -(2132:4-2132:8) " if " --> (1340:0-1340:8) "\n\t\t\t\tif " -(2132:8-2132:19) "(propTypes)" --> (1340:8-1340:19) "(propTypes)" -(2132:19-2134:6) " {\n // Intentionally inside to avoid triggering lazy initializers:\n " --> (1340:19-1341:5) " {\n\t\t\t\t" -(2134:6-2134:10) " var" --> (1341:5-1341:9) "\tvar" -(2134:10-2134:17) " name =" --> (1341:9-1341:16) " name =" -(2134:17-2134:34) " getComponentName" --> (1341:16-1341:33) " getComponentName" -(2134:34-2134:39) "(type" --> (1341:33-1341:38) "(type" -(2134:39-2135:6) ");\n " --> (1341:38-1342:0) ");" -(2135:6-2135:21) " checkPropTypes" --> (1342:0-1342:20) "\n\t\t\t\t\tcheckPropTypes" -(2135:21-2135:32) "(propTypes," --> (1342:20-1342:31) "(propTypes," -(2135:32-2135:40) " element" --> (1342:31-1342:39) " element" -(2135:40-2135:47) ".props," --> (1342:39-1342:46) ".props," -(2135:47-2135:55) " 'prop'," --> (1342:46-1342:54) " \"prop\"," -(2135:55-2135:61) " name," --> (1342:54-1342:60) " name," -(2135:61-2135:69) " element" --> (1342:60-1342:68) " element" -(2135:69-2136:5) ");\n " --> (1342:68-1343:4) ");\n\t\t\t" -(2136:5-2136:15) "} else if " --> (1343:4-1343:15) "\t} else if " -(2136:15-2136:20) "(type" --> (1343:15-1343:20) "(type" -(2136:20-2136:34) ".PropTypes !==" --> (1343:20-1343:34) ".PropTypes !==" -(2136:34-2136:48) " undefined && " --> (1343:34-1343:48) " undefined && " -(2136:48-2136:79) "!propTypesMisspellWarningShown)" --> (1343:48-1343:79) "!propTypesMisspellWarningShown)" -(2136:79-2137:6) " {\n " --> (1343:79-1344:0) " {" -(2137:6-2137:38) " propTypesMisspellWarningShown =" --> (1344:0-1344:37) "\n\t\t\t\t\tpropTypesMisspellWarningShown =" -(2137:38-2139:6) " true; // Intentionally inside to avoid triggering lazy initializers:\n\n " --> (1344:37-1345:5) " true;\n\t\t\t\t" -(2139:6-2139:10) " var" --> (1345:5-1345:9) "\tvar" -(2139:10-2139:18) " _name =" --> (1345:9-1345:17) " _name =" -(2139:18-2139:35) " getComponentName" --> (1345:17-1345:34) " getComponentName" -(2139:35-2139:40) "(type" --> (1345:34-1345:39) "(type" -(2139:40-2141:6) ");\n\n " --> (1345:39-1346:0) ");" -(2141:6-2141:12) " error" --> (1346:0-1346:11) "\n\t\t\t\t\terror" -(2141:12-2141:115) "('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?'," --> (1346:11-1346:114) "(\"Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?\"," -(2141:115-2141:124) " _name ||" --> (1346:114-1346:123) " _name ||" -(2141:124-2141:134) " 'Unknown'" --> (1346:123-1346:133) " \"Unknown\"" -(2141:134-2142:5) ");\n " --> (1346:133-1347:4) ");\n\t\t\t" -(2142:5-2144:4) "}\n\n " --> (1347:4-1348:0) "\t}" -(2144:4-2144:15) " if (typeof" --> (1348:0-1348:15) "\n\t\t\t\tif (typeof" -(2144:15-2144:20) " type" --> (1348:15-1348:20) " type" -(2144:20-2144:40) ".getDefaultProps ===" --> (1348:20-1348:40) ".getDefaultProps ===" -(2144:40-2144:55) " 'function' && " --> (1348:40-1348:55) " \"function\" && " -(2144:55-2144:60) "!type" --> (1348:55-1348:60) "!type" -(2144:60-2144:76) ".getDefaultProps" --> (1348:60-1348:76) ".getDefaultProps" -(2144:76-2144:98) ".isReactClassApproved)" --> (1348:76-1348:98) ".isReactClassApproved)" -(2144:98-2145:6) " {\n " --> (1348:98-1349:0) " {" -(2145:6-2145:12) " error" --> (1349:0-1349:11) "\n\t\t\t\t\terror" -(2145:12-2145:75) "('getDefaultProps is only used on classic React.createClass ' +" --> (1349:11-1349:74) "(\"getDefaultProps is only used on classic React.createClass \" +" -(2145:75-2145:142) " 'definitions. Use a static property named `defaultProps` instead.'" --> (1349:74-1349:141) " \"definitions. Use a static property named `defaultProps` instead.\"" -(2145:142-2146:5) ");\n " --> (1349:141-1350:4) ");\n\t\t\t" -(2146:5-2147:3) "}\n " --> (1350:4-1351:3) "\t}\n\t\t" -(2147:3-2148:1) "}\n" --> (1351:3-1352:2) "\t}\n\t" -(2148:1-2155:0) "}\n/**\n * Given a fragment, validate that it can only be provided with fragment props\n * @param {ReactElement} fragment\n */\n\n" --> (1352:2-1353:2) "\t}\n\t" -(2155:0-2155:9) "\nfunction" --> (1353:2-1353:11) "\tfunction" -(2155:9-2155:31) " validateFragmentProps" --> (1353:11-1353:33) " validateFragmentProps" -(2155:31-2155:41) "(fragment)" --> (1353:33-1353:43) "(fragment)" -(2155:41-2156:2) " {\n " --> (1353:43-1354:3) " {\n\t\t" -(2156:2-2157:4) " {\n " --> (1354:3-1355:4) "\t{\n\t\t\t" -(2157:4-2157:8) " var" --> (1355:4-1355:8) "\tvar" -(2157:8-2157:15) " keys =" --> (1355:8-1355:15) " keys =" -(2157:15-2157:22) " Object" --> (1355:15-1355:22) " Object" -(2157:22-2157:27) ".keys" --> (1355:22-1355:27) ".keys" -(2157:27-2157:36) "(fragment" --> (1355:27-1355:36) "(fragment" -(2157:36-2157:42) ".props" --> (1355:36-1355:42) ".props" -(2157:42-2159:4) ");\n\n " --> (1355:42-1356:0) ");" -(2159:4-2159:9) " for " --> (1356:0-1356:9) "\n\t\t\t\tfor " -(2159:9-2159:13) "(var" --> (1356:9-1356:13) "(var" -(2159:13-2159:17) " i =" --> (1356:13-1356:17) " i =" -(2159:17-2159:20) " 0;" --> (1356:17-1356:20) " 0;" -(2159:20-2159:24) " i <" --> (1356:20-1356:24) " i <" -(2159:24-2159:29) " keys" --> (1356:24-1356:29) " keys" -(2159:29-2159:37) ".length;" --> (1356:29-1356:37) ".length;" -(2159:37-2159:42) " i++)" --> (1356:37-1356:42) " i++)" -(2159:42-2160:6) " {\n " --> (1356:42-1357:5) " {\n\t\t\t\t" -(2160:6-2160:10) " var" --> (1357:5-1357:9) "\tvar" -(2160:10-2160:16) " key =" --> (1357:9-1357:15) " key =" -(2160:16-2160:21) " keys" --> (1357:15-1357:20) " keys" -(2160:21-2162:6) "[i];\n\n " --> (1357:20-1358:0) "[i];" -(2162:6-2162:10) " if " --> (1358:0-1358:9) "\n\t\t\t\t\tif " -(2162:10-2162:18) "(key !==" --> (1358:9-1358:17) "(key !==" -(2162:18-2162:32) " 'children' &&" --> (1358:17-1358:31) " \"children\" &&" -(2162:32-2162:40) " key !==" --> (1358:31-1358:39) " key !==" -(2162:40-2162:47) " 'key')" --> (1358:39-1358:46) " \"key\")" -(2162:47-2163:8) " {\n " --> (1358:46-1359:0) " {" -(2163:8-2163:40) " setCurrentlyValidatingElement$1" --> (1359:0-1359:38) "\n\t\t\t\t\t\tsetCurrentlyValidatingElement$1" -(2163:40-2163:49) "(fragment" --> (1359:38-1359:47) "(fragment" -(2163:49-2165:8) ");\n\n " --> (1359:47-1360:0) ");" -(2165:8-2165:14) " error" --> (1360:0-1360:12) "\n\t\t\t\t\t\terror" -(2165:14-2165:67) "('Invalid prop `%s` supplied to `React.Fragment`. ' +" --> (1360:12-1360:65) "(\"Invalid prop `%s` supplied to `React.Fragment`. \" +" -(2165:67-2165:127) " 'React.Fragment can only have `key` and `children` props.'," --> (1360:65-1360:125) " \"React.Fragment can only have `key` and `children` props.\"," -(2165:127-2165:131) " key" --> (1360:125-1360:129) " key" -(2165:131-2167:8) ");\n\n " --> (1360:129-1361:0) ");" -(2167:8-2167:40) " setCurrentlyValidatingElement$1" --> (1361:0-1361:38) "\n\t\t\t\t\t\tsetCurrentlyValidatingElement$1" -(2167:40-2167:45) "(null" --> (1361:38-1361:43) "(null" -(2167:45-2168:8) ");\n " --> (1361:43-1362:0) ");" -(2168:8-2169:7) " break;\n " --> (1362:0-1363:5) "\n\t\t\t\t\t\tbreak;\n\t\t\t\t" -(2169:7-2170:5) "}\n " --> (1363:5-1364:4) "\t}\n\t\t\t" -(2170:5-2172:4) "}\n\n " --> (1364:4-1365:0) "\t}" -(2172:4-2172:8) " if " --> (1365:0-1365:8) "\n\t\t\t\tif " -(2172:8-2172:17) "(fragment" --> (1365:8-1365:17) "(fragment" -(2172:17-2172:25) ".ref !==" --> (1365:17-1365:25) ".ref !==" -(2172:25-2172:31) " null)" --> (1365:25-1365:31) " null)" -(2172:31-2173:6) " {\n " --> (1365:31-1366:0) " {" -(2173:6-2173:38) " setCurrentlyValidatingElement$1" --> (1366:0-1366:37) "\n\t\t\t\t\tsetCurrentlyValidatingElement$1" -(2173:38-2173:47) "(fragment" --> (1366:37-1366:46) "(fragment" -(2173:47-2175:6) ");\n\n " --> (1366:46-1367:0) ");" -(2175:6-2175:12) " error" --> (1367:0-1367:11) "\n\t\t\t\t\terror" -(2175:12-2175:68) "('Invalid attribute `ref` supplied to `React.Fragment`.'" --> (1367:11-1367:67) "(\"Invalid attribute `ref` supplied to `React.Fragment`.\"" -(2175:68-2177:6) ");\n\n " --> (1367:67-1368:0) ");" -(2177:6-2177:38) " setCurrentlyValidatingElement$1" --> (1368:0-1368:37) "\n\t\t\t\t\tsetCurrentlyValidatingElement$1" -(2177:38-2177:43) "(null" --> (1368:37-1368:42) "(null" -(2177:43-2178:5) ");\n " --> (1368:42-1369:4) ");\n\t\t\t" -(2178:5-2179:3) "}\n " --> (1369:4-1370:3) "\t}\n\t\t" -(2179:3-2180:1) "}\n" --> (1370:3-1371:2) "\t}\n\t" -(2180:1-2181:0) "}" --> (1371:2-1372:2) "\t}\n\t" -(2181:0-2181:9) "\nfunction" --> (1372:2-1372:11) "\tfunction" -(2181:9-2181:37) " createElementWithValidation" --> (1372:11-1372:39) " createElementWithValidation" -(2181:37-2181:43) "(type," --> (1372:39-1372:45) "(type," -(2181:43-2181:50) " props," --> (1372:45-1372:52) " props," -(2181:50-2181:60) " children)" --> (1372:52-1372:62) " children)" -(2181:60-2182:2) " {\n " --> (1372:62-1373:3) " {\n\t\t" -(2182:2-2182:6) " var" --> (1373:3-1373:7) "\tvar" -(2182:6-2182:18) " validType =" --> (1373:7-1373:19) " validType =" -(2182:18-2182:37) " isValidElementType" --> (1373:19-1373:38) " isValidElementType" -(2182:37-2182:42) "(type" --> (1373:38-1373:43) "(type" -(2182:42-2185:2) "); // We warn in this case but don't throw. We expect the element creation to\n // succeed and there will likely be errors in render.\n\n " --> (1373:43-1374:0) ");" -(2185:2-2185:7) " if (" --> (1374:0-1374:8) "\n\t\t\tif (" -(2185:7-2185:18) "!validType)" --> (1374:8-1374:19) "!validType)" -(2185:18-2186:4) " {\n " --> (1374:19-1375:4) " {\n\t\t\t" -(2186:4-2186:8) " var" --> (1375:4-1375:8) "\tvar" -(2186:8-2186:15) " info =" --> (1375:8-1375:15) " info =" -(2186:15-2188:4) " '';\n\n " --> (1375:15-1376:0) " \"\";" -(2188:4-2188:8) " if " --> (1376:0-1376:8) "\n\t\t\t\tif " -(2188:8-2188:17) "(type ===" --> (1376:8-1376:17) "(type ===" -(2188:17-2188:37) " undefined || typeof" --> (1376:17-1376:37) " undefined || typeof" -(2188:37-2188:46) " type ===" --> (1376:37-1376:46) " type ===" -(2188:46-2188:58) " 'object' &&" --> (1376:46-1376:58) " \"object\" &&" -(2188:58-2188:67) " type !==" --> (1376:58-1376:67) " type !==" -(2188:67-2188:75) " null &&" --> (1376:67-1376:75) " null &&" -(2188:75-2188:82) " Object" --> (1376:75-1376:82) " Object" -(2188:82-2188:87) ".keys" --> (1376:82-1376:87) ".keys" -(2188:87-2188:92) "(type" --> (1376:87-1376:92) "(type" -(2188:92-2188:93) ")" --> (1376:92-1376:93) ")" -(2188:93-2188:104) ".length ===" --> (1376:93-1376:104) ".length ===" -(2188:104-2188:107) " 0)" --> (1376:104-1376:107) " 0)" -(2188:107-2189:6) " {\n " --> (1376:107-1377:0) " {" -(2189:6-2189:14) " info +=" --> (1377:0-1377:13) "\n\t\t\t\t\tinfo +=" -(2189:14-2189:77) " ' You likely forgot to export your component from the file ' +" --> (1377:13-1377:76) " \" You likely forgot to export your component from the file \" +" -(2189:77-2190:5) " \"it's defined in, or you might have mixed up default and named imports.\";\n " --> (1377:76-1378:4) " \"it's defined in, or you might have mixed up default and named imports.\";\n\t\t\t" -(2190:5-2192:4) "}\n\n " --> (1378:4-1379:4) "\t}\n\t\t\t" -(2192:4-2192:8) " var" --> (1379:4-1379:8) "\tvar" -(2192:8-2192:21) " sourceInfo =" --> (1379:8-1379:21) " sourceInfo =" -(2192:21-2192:56) " getSourceInfoErrorAddendumForProps" --> (1379:21-1379:56) " getSourceInfoErrorAddendumForProps" -(2192:56-2192:62) "(props" --> (1379:56-1379:62) "(props" -(2192:62-2194:4) ");\n\n " --> (1379:62-1380:0) ");" -(2194:4-2194:8) " if " --> (1380:0-1380:8) "\n\t\t\t\tif " -(2194:8-2194:20) "(sourceInfo)" --> (1380:8-1380:20) "(sourceInfo)" -(2194:20-2195:6) " {\n " --> (1380:20-1381:0) " {" -(2195:6-2195:14) " info +=" --> (1381:0-1381:13) "\n\t\t\t\t\tinfo +=" -(2195:14-2196:5) " sourceInfo;\n " --> (1381:13-1382:4) " sourceInfo;\n\t\t\t" -(2196:5-2196:11) "} else" --> (1382:4-1382:11) "\t} else" -(2196:11-2197:6) " {\n " --> (1382:11-1383:0) " {" -(2197:6-2197:14) " info +=" --> (1383:0-1383:13) "\n\t\t\t\t\tinfo +=" -(2197:14-2197:43) " getDeclarationErrorAddendum(" --> (1383:13-1383:42) " getDeclarationErrorAddendum(" -(2197:43-2198:5) ");\n " --> (1383:42-1384:4) ");\n\t\t\t" -(2198:5-2200:4) "}\n\n " --> (1384:4-1385:4) "\t}\n\t\t\t" -(2200:4-2200:8) " var" --> (1385:4-1385:8) "\tvar" -(2200:8-2202:4) " typeString;\n\n " --> (1385:8-1386:0) " typeString;" -(2202:4-2202:8) " if " --> (1386:0-1386:8) "\n\t\t\t\tif " -(2202:8-2202:17) "(type ===" --> (1386:8-1386:17) "(type ===" -(2202:17-2202:23) " null)" --> (1386:17-1386:23) " null)" -(2202:23-2203:6) " {\n " --> (1386:23-1387:0) " {" -(2203:6-2203:19) " typeString =" --> (1387:0-1387:18) "\n\t\t\t\t\ttypeString =" -(2203:19-2204:5) " 'null';\n " --> (1387:18-1388:4) " \"null\";\n\t\t\t" -(2204:5-2204:15) "} else if " --> (1388:4-1388:15) "\t} else if " -(2204:15-2204:21) "(Array" --> (1388:15-1388:21) "(Array" -(2204:21-2204:29) ".isArray" --> (1388:21-1388:29) ".isArray" -(2204:29-2204:34) "(type" --> (1388:29-1388:34) "(type" -(2204:34-2204:36) "))" --> (1388:34-1388:36) "))" -(2204:36-2205:6) " {\n " --> (1388:36-1389:0) " {" -(2205:6-2205:19) " typeString =" --> (1389:0-1389:18) "\n\t\t\t\t\ttypeString =" -(2205:19-2206:5) " 'array';\n " --> (1389:18-1390:4) " \"array\";\n\t\t\t" -(2206:5-2206:15) "} else if " --> (1390:4-1390:15) "\t} else if " -(2206:15-2206:24) "(type !==" --> (1390:15-1390:24) "(type !==" -(2206:24-2206:37) " undefined &&" --> (1390:24-1390:37) " undefined &&" -(2206:37-2206:42) " type" --> (1390:37-1390:42) " type" -(2206:42-2206:55) ".$$typeof ===" --> (1390:42-1390:55) ".$$typeof ===" -(2206:55-2206:75) " REACT_ELEMENT_TYPE)" --> (1390:55-1390:75) " REACT_ELEMENT_TYPE)" -(2206:75-2207:6) " {\n " --> (1390:75-1391:0) " {" -(2207:6-2207:19) " typeString =" --> (1391:0-1391:18) "\n\t\t\t\t\ttypeString =" -(2207:19-2207:26) " \"<\" + " --> (1391:18-1391:25) " \"<\" + " -(2207:26-2207:43) "(getComponentName" --> (1391:25-1391:42) "(getComponentName" -(2207:43-2207:48) "(type" --> (1391:42-1391:47) "(type" -(2207:48-2207:53) ".type" --> (1391:47-1391:52) ".type" -(2207:53-2207:57) ") ||" --> (1391:52-1391:56) ") ||" -(2207:57-2207:70) " 'Unknown') +" --> (1391:56-1391:69) " \"Unknown\") +" -(2207:70-2208:6) " \" />\";\n " --> (1391:69-1392:0) " \" />\";" -(2208:6-2208:13) " info =" --> (1392:0-1392:12) "\n\t\t\t\t\tinfo =" -(2208:13-2209:5) " ' Did you accidentally export a JSX literal instead of a component?';\n " --> (1392:12-1393:4) " \" Did you accidentally export a JSX literal instead of a component?\";\n\t\t\t" -(2209:5-2209:11) "} else" --> (1393:4-1393:11) "\t} else" -(2209:11-2210:6) " {\n " --> (1393:11-1394:0) " {" -(2210:6-2210:26) " typeString = typeof" --> (1394:0-1394:25) "\n\t\t\t\t\ttypeString = typeof" -(2210:26-2211:5) " type;\n " --> (1394:25-1395:4) " type;\n\t\t\t" -(2211:5-2213:4) "}\n\n " --> (1395:4-1396:4) "\t}\n\t\t\t" -(2213:4-2214:6) " {\n " --> (1396:4-1397:0) "\t{" -(2214:6-2214:12) " error" --> (1397:0-1397:11) "\n\t\t\t\t\terror" -(2214:12-2214:80) "('React.createElement: type is invalid -- expected a string (for ' +" --> (1397:11-1397:79) "(\"React.createElement: type is invalid -- expected a string (for \" +" -(2214:80-2214:141) " 'built-in components) or a class/function (for composite ' +" --> (1397:79-1397:140) " \"built-in components) or a class/function (for composite \" +" -(2214:141-2214:171) " 'components) but got: %s.%s'," --> (1397:140-1397:170) " \"components) but got: %s.%s\"," -(2214:171-2214:183) " typeString," --> (1397:170-1397:182) " typeString," -(2214:183-2214:188) " info" --> (1397:182-1397:187) " info" -(2214:188-2215:5) ");\n " --> (1397:187-1398:4) ");\n\t\t\t" -(2215:5-2216:3) "}\n " --> (1398:4-1399:3) "\t}\n\t\t" -(2216:3-2218:2) "}\n\n " --> (1399:3-1400:3) "\t}\n\t\t" -(2218:2-2218:6) " var" --> (1400:3-1400:7) "\tvar" -(2218:6-2218:16) " element =" --> (1400:7-1400:17) " element =" -(2218:16-2218:30) " createElement" --> (1400:17-1400:31) " createElement" -(2218:30-2218:36) ".apply" --> (1400:31-1400:37) ".apply" -(2218:36-2218:42) "(this," --> (1400:37-1400:43) "(this," -(2218:42-2218:52) " arguments" --> (1400:43-1400:53) " arguments" -(2218:52-2221:2) "); // The result can be nullish if a mock or a custom function is used.\n // TODO: Drop this when these are no longer allowed as the type argument.\n\n " --> (1400:53-1401:0) ");" -(2221:2-2221:6) " if " --> (1401:0-1401:7) "\n\t\t\tif " -(2221:6-2221:17) "(element ==" --> (1401:7-1401:18) "(element ==" -(2221:17-2221:23) " null)" --> (1401:18-1401:24) " null)" -(2221:23-2222:4) " {\n " --> (1401:24-1402:0) " {" -(2222:4-2222:11) " return" --> (1402:0-1402:11) "\n\t\t\t\treturn" -(2222:11-2223:3) " element;\n " --> (1402:11-1403:3) " element;\n\t\t" -(2223:3-2230:2) "} // Skip key warning if the type isn't valid since our key validation logic\n // doesn't expect a non-string/function type and can throw confusing errors.\n // We don't want exception behavior to differ between dev and prod.\n // (Rendering will throw with a helpful message and as soon as the type is\n // fixed, the key warnings will appear.)\n\n\n " --> (1403:3-1404:0) "\t}" -(2230:2-2230:6) " if " --> (1404:0-1404:7) "\n\t\t\tif " -(2230:6-2230:17) "(validType)" --> (1404:7-1404:18) "(validType)" -(2230:17-2231:4) " {\n " --> (1404:18-1405:0) " {" -(2231:4-2231:9) " for " --> (1405:0-1405:9) "\n\t\t\t\tfor " -(2231:9-2231:13) "(var" --> (1405:9-1405:13) "(var" -(2231:13-2231:17) " i =" --> (1405:13-1405:17) " i =" -(2231:17-2231:20) " 2;" --> (1405:17-1405:20) " 2;" -(2231:20-2231:24) " i <" --> (1405:20-1405:24) " i <" -(2231:24-2231:34) " arguments" --> (1405:24-1405:34) " arguments" -(2231:34-2231:42) ".length;" --> (1405:34-1405:42) ".length;" -(2231:42-2231:47) " i++)" --> (1405:42-1405:47) " i++)" -(2231:47-2232:6) " {\n " --> (1405:47-1406:0) " {" -(2232:6-2232:24) " validateChildKeys" --> (1406:0-1406:23) "\n\t\t\t\t\tvalidateChildKeys" -(2232:24-2232:34) "(arguments" --> (1406:23-1406:33) "(arguments" -(2232:34-2232:38) "[i]," --> (1406:33-1406:37) "[i]," -(2232:38-2232:43) " type" --> (1406:37-1406:42) " type" -(2232:43-2233:5) ");\n " --> (1406:42-1407:4) ");\n\t\t\t" -(2233:5-2234:3) "}\n " --> (1407:4-1408:3) "\t}\n\t\t" -(2234:3-2236:2) "}\n\n " --> (1408:3-1409:0) "\t}" -(2236:2-2236:6) " if " --> (1409:0-1409:7) "\n\t\t\tif " -(2236:6-2236:15) "(type ===" --> (1409:7-1409:16) "(type ===" -(2236:15-2236:23) " exports" --> (1409:16-1409:24) " exports" -(2236:23-2236:33) ".Fragment)" --> (1409:24-1409:34) ".Fragment)" -(2236:33-2237:4) " {\n " --> (1409:34-1410:0) " {" -(2237:4-2237:26) " validateFragmentProps" --> (1410:0-1410:26) "\n\t\t\t\tvalidateFragmentProps" -(2237:26-2237:34) "(element" --> (1410:26-1410:34) "(element" -(2237:34-2238:3) ");\n " --> (1410:34-1411:3) ");\n\t\t" -(2238:3-2238:9) "} else" --> (1411:3-1411:10) "\t} else" -(2238:9-2239:4) " {\n " --> (1411:10-1412:0) " {" -(2239:4-2239:22) " validatePropTypes" --> (1412:0-1412:22) "\n\t\t\t\tvalidatePropTypes" -(2239:22-2239:30) "(element" --> (1412:22-1412:30) "(element" -(2239:30-2240:3) ");\n " --> (1412:30-1413:3) ");\n\t\t" -(2240:3-2242:2) "}\n\n " --> (1413:3-1414:0) "\t}" -(2242:2-2242:9) " return" --> (1414:0-1414:10) "\n\t\t\treturn" -(2242:9-2243:1) " element;\n" --> (1414:10-1415:2) " element;\n\t" -(2243:1-2244:0) "}" --> (1415:2-1416:2) "\t}\n\t" -(2244:0-2244:4) "\nvar" --> (1416:2-1416:6) "\tvar" -(2244:4-2244:42) " didWarnAboutDeprecatedCreateFactory =" --> (1416:6-1416:44) " didWarnAboutDeprecatedCreateFactory =" -(2244:42-2245:0) " false;" --> (1416:44-1417:2) " false;\n\t" -(2245:0-2245:9) "\nfunction" --> (1417:2-1417:11) "\tfunction" -(2245:9-2245:37) " createFactoryWithValidation" --> (1417:11-1417:39) " createFactoryWithValidation" -(2245:37-2245:43) "(type)" --> (1417:39-1417:45) "(type)" -(2245:43-2246:2) " {\n " --> (1417:45-1418:3) " {\n\t\t" -(2246:2-2246:6) " var" --> (1418:3-1418:7) "\tvar" -(2246:6-2246:25) " validatedFactory =" --> (1418:7-1418:26) " validatedFactory =" -(2246:25-2246:53) " createElementWithValidation" --> (1418:26-1418:54) " createElementWithValidation" -(2246:53-2246:58) ".bind" --> (1418:54-1418:59) ".bind" -(2246:58-2246:64) "(null," --> (1418:59-1418:65) "(null," -(2246:64-2246:69) " type" --> (1418:65-1418:70) " type" -(2246:69-2247:2) ");\n " --> (1418:70-1419:0) ");" -(2247:2-2247:19) " validatedFactory" --> (1419:0-1419:20) "\n\t\t\tvalidatedFactory" -(2247:19-2247:26) ".type =" --> (1419:20-1419:27) ".type =" -(2247:26-2249:2) " type;\n\n " --> (1419:27-1420:3) " type;\n\t\t" -(2249:2-2250:4) " {\n " --> (1420:3-1421:0) "\t{" -(2250:4-2250:9) " if (" --> (1421:0-1421:9) "\n\t\t\t\tif (" -(2250:9-2250:46) "!didWarnAboutDeprecatedCreateFactory)" --> (1421:9-1421:46) "!didWarnAboutDeprecatedCreateFactory)" -(2250:46-2251:6) " {\n " --> (1421:46-1422:0) " {" -(2251:6-2251:44) " didWarnAboutDeprecatedCreateFactory =" --> (1422:0-1422:43) "\n\t\t\t\t\tdidWarnAboutDeprecatedCreateFactory =" -(2251:44-2253:6) " true;\n\n " --> (1422:43-1423:0) " true;" -(2253:6-2253:11) " warn" --> (1423:0-1423:10) "\n\t\t\t\t\twarn" -(2253:11-2253:75) "('React.createFactory() is deprecated and will be removed in ' +" --> (1423:10-1423:74) "(\"React.createFactory() is deprecated and will be removed in \" +" -(2253:75-2253:123) " 'a future major release. Consider using JSX ' +" --> (1423:74-1423:122) " \"a future major release. Consider using JSX \" +" -(2253:123-2253:172) " 'or use React.createElement() directly instead.'" --> (1423:122-1423:171) " \"or use React.createElement() directly instead.\"" -(2253:172-2254:5) ");\n " --> (1423:171-1424:4) ");\n\t\t\t" -(2254:5-2257:4) "} // Legacy hook: remove it\n\n\n " --> (1424:4-1425:0) "\t}" -(2257:4-2257:11) " Object" --> (1425:0-1425:11) "\n\t\t\t\tObject" -(2257:11-2257:26) ".defineProperty" --> (1425:11-1425:26) ".defineProperty" -(2257:26-2257:44) "(validatedFactory," --> (1425:26-1425:44) "(validatedFactory," -(2257:44-2257:52) " 'type'," --> (1425:44-1425:52) " \"type\"," -(2257:52-2258:6) " {\n " --> (1425:52-1426:5) " {\n\t\t\t\t" -(2258:6-2258:18) " enumerable:" --> (1426:5-1426:17) "\tenumerable:" -(2258:18-2259:6) " false,\n " --> (1426:17-1427:5) " false,\n\t\t\t\t" -(2259:6-2259:11) " get:" --> (1427:5-1427:10) "\tget:" -(2259:11-2259:23) " function ()" --> (1427:10-1427:21) " function()" -(2259:23-2260:8) " {\n " --> (1427:21-1428:0) " {" -(2260:8-2260:13) " warn" --> (1428:0-1428:11) "\n\t\t\t\t\t\twarn" -(2260:13-2260:72) "('Factory.type is deprecated. Access the class directly ' +" --> (1428:11-1428:70) "(\"Factory.type is deprecated. Access the class directly \" +" -(2260:72-2260:110) " 'before passing it to createFactory.'" --> (1428:70-1428:108) " \"before passing it to createFactory.\"" -(2260:110-2262:8) ");\n\n " --> (1428:108-1429:0) ");" -(2262:8-2262:15) " Object" --> (1429:0-1429:13) "\n\t\t\t\t\t\tObject" -(2262:15-2262:30) ".defineProperty" --> (1429:13-1429:28) ".defineProperty" -(2262:30-2262:36) "(this," --> (1429:28-1429:34) "(this," -(2262:36-2262:44) " 'type'," --> (1429:34-1429:42) " \"type\"," -(2262:44-2263:10) " {\n " --> (1429:42-1429:44) " {" -(2263:10-2263:17) " value:" --> (1429:44-1429:51) " value:" -(2263:17-2264:9) " type\n " --> (1429:51-1429:56) " type" -(2264:9-2264:10) "}" --> (1429:56-1429:58) " }" -(2264:10-2265:8) ");\n " --> (1429:58-1430:0) ");" -(2265:8-2265:15) " return" --> (1430:0-1430:13) "\n\t\t\t\t\t\treturn" -(2265:15-2266:7) " type;\n " --> (1430:13-1431:5) " type;\n\t\t\t\t" -(2266:7-2267:5) "}\n " --> (1431:5-1432:4) "\t}\n\t\t\t" -(2267:5-2267:6) "}" --> (1432:4-1432:6) "\t}" -(2267:6-2268:3) ");\n " --> (1432:6-1433:3) ");\n\t\t" -(2268:3-2270:2) "}\n\n " --> (1433:3-1434:0) "\t}" -(2270:2-2270:9) " return" --> (1434:0-1434:10) "\n\t\t\treturn" -(2270:9-2271:1) " validatedFactory;\n" --> (1434:10-1435:2) " validatedFactory;\n\t" -(2271:1-2272:0) "}" --> (1435:2-1436:2) "\t}\n\t" -(2272:0-2272:9) "\nfunction" --> (1436:2-1436:11) "\tfunction" -(2272:9-2272:36) " cloneElementWithValidation" --> (1436:11-1436:38) " cloneElementWithValidation" -(2272:36-2272:45) "(element," --> (1436:38-1436:47) "(element," -(2272:45-2272:52) " props," --> (1436:47-1436:54) " props," -(2272:52-2272:62) " children)" --> (1436:54-1436:64) " children)" -(2272:62-2273:2) " {\n " --> (1436:64-1437:3) " {\n\t\t" -(2273:2-2273:6) " var" --> (1437:3-1437:7) "\tvar" -(2273:6-2273:19) " newElement =" --> (1437:7-1437:20) " newElement =" -(2273:19-2273:32) " cloneElement" --> (1437:20-1437:33) " cloneElement" -(2273:32-2273:38) ".apply" --> (1437:33-1437:39) ".apply" -(2273:38-2273:44) "(this," --> (1437:39-1437:45) "(this," -(2273:44-2273:54) " arguments" --> (1437:45-1437:55) " arguments" -(2273:54-2275:2) ");\n\n " --> (1437:55-1438:0) ");" -(2275:2-2275:7) " for " --> (1438:0-1438:8) "\n\t\t\tfor " -(2275:7-2275:11) "(var" --> (1438:8-1438:12) "(var" -(2275:11-2275:15) " i =" --> (1438:12-1438:16) " i =" -(2275:15-2275:18) " 2;" --> (1438:16-1438:19) " 2;" -(2275:18-2275:22) " i <" --> (1438:19-1438:23) " i <" -(2275:22-2275:32) " arguments" --> (1438:23-1438:33) " arguments" -(2275:32-2275:40) ".length;" --> (1438:33-1438:41) ".length;" -(2275:40-2275:45) " i++)" --> (1438:41-1438:46) " i++)" -(2275:45-2276:4) " {\n " --> (1438:46-1439:0) " {" -(2276:4-2276:22) " validateChildKeys" --> (1439:0-1439:22) "\n\t\t\t\tvalidateChildKeys" -(2276:22-2276:32) "(arguments" --> (1439:22-1439:32) "(arguments" -(2276:32-2276:36) "[i]," --> (1439:32-1439:36) "[i]," -(2276:36-2276:47) " newElement" --> (1439:36-1439:47) " newElement" -(2276:47-2276:52) ".type" --> (1439:47-1439:52) ".type" -(2276:52-2277:3) ");\n " --> (1439:52-1440:3) ");\n\t\t" -(2277:3-2279:2) "}\n\n " --> (1440:3-1441:0) "\t}" -(2279:2-2279:20) " validatePropTypes" --> (1441:0-1441:21) "\n\t\t\tvalidatePropTypes" -(2279:20-2279:31) "(newElement" --> (1441:21-1441:32) "(newElement" -(2279:31-2280:2) ");\n " --> (1441:32-1442:0) ");" -(2280:2-2280:9) " return" --> (1442:0-1442:10) "\n\t\t\treturn" -(2280:9-2281:1) " newElement;\n" --> (1442:10-1443:2) " newElement;\n\t" -(2281:1-2283:0) "}\n" --> (1443:2-1444:2) "\t}\n\t" -(2283:0-2285:2) "\n{\n\n " --> (1444:2-1445:0) "\t{" -(2285:2-2285:6) " try" --> (1445:0-1445:7) "\n\t\t\ttry" -(2285:6-2286:4) " {\n " --> (1445:7-1446:4) " {\n\t\t\t" -(2286:4-2286:8) " var" --> (1446:4-1446:8) "\tvar" -(2286:8-2286:23) " frozenObject =" --> (1446:8-1446:23) " frozenObject =" -(2286:23-2286:30) " Object" --> (1446:23-1446:30) " Object" -(2286:30-2286:37) ".freeze" --> (1446:30-1446:37) ".freeze" -(2286:37-2286:39) "({" --> (1446:37-1446:38) "(" -(2286:39-2286:40) "}" --> (1446:38-1446:40) "{}" -(2286:40-2289:4) ");\n /* eslint-disable no-new */\n\n " --> (1446:40-1447:0) ");" -(2289:4-2289:8) " new" --> (1447:0-1447:8) "\n\t\t\t\tnew" -(2289:8-2289:12) " Map" --> (1447:8-1447:12) " Map" -(2289:12-2289:13) "(" --> (1447:12-1447:13) "(" -(2289:13-2289:14) "[" --> (1447:13-1447:14) "[" -(2289:14-2289:28) "[frozenObject," --> (1447:14-1447:28) "[frozenObject," -(2289:28-2289:33) " null" --> (1447:28-1447:33) " null" -(2289:33-2289:34) "]" --> (1447:33-1447:34) "]" -(2289:34-2290:4) "]);\n " --> (1447:34-1448:0) "]);" -(2290:4-2290:8) " new" --> (1448:0-1448:8) "\n\t\t\t\tnew" -(2290:8-2290:12) " Set" --> (1448:8-1448:12) " Set" -(2290:12-2290:13) "(" --> (1448:12-1448:13) "(" -(2290:13-2290:26) "[frozenObject" --> (1448:13-1448:26) "[frozenObject" -(2290:26-2292:3) "]);\n /* eslint-enable no-new */\n " --> (1448:26-1449:3) "]);\n\t\t" -(2292:3-2292:11) "} catch " --> (1449:3-1449:12) "\t} catch " -(2292:11-2292:14) "(e)" --> (1449:12-1449:15) "(e)" -(2292:14-2293:3) " {\n " --> (1449:15-1449:16) " " -(2293:3-2294:1) "}\n" --> (1449:16-1450:2) "{}\n\t" -(2294:1-2296:0) "}\n" --> (1450:2-1451:2) "\t}\n\t" -(2296:0-2296:4) "\nvar" --> (1451:2-1451:6) "\tvar" -(2296:4-2296:23) " createElement$1 = " --> (1451:6-1451:24) " createElement$1 =" -(2296:23-2297:0) " createElementWithValidation ;" --> (1451:24-1452:2) " createElementWithValidation;\n\t" -(2297:0-2297:4) "\nvar" --> (1452:2-1452:6) "\tvar" -(2297:4-2297:22) " cloneElement$1 = " --> (1452:6-1452:23) " cloneElement$1 =" -(2297:22-2298:0) " cloneElementWithValidation ;" --> (1452:23-1453:2) " cloneElementWithValidation;\n\t" -(2298:0-2298:4) "\nvar" --> (1453:2-1453:6) "\tvar" -(2298:4-2298:21) " createFactory = " --> (1453:6-1453:22) " createFactory =" -(2298:21-2299:0) " createFactoryWithValidation ;" --> (1453:22-1454:2) " createFactoryWithValidation;\n\t" -(2299:0-2299:4) "\nvar" --> (1454:2-1454:6) "\tvar" -(2299:4-2299:15) " Children =" --> (1454:6-1454:17) " Children =" -(2299:15-2300:2) " {\n " --> (1454:17-1455:3) " {\n\t\t" -(2300:2-2300:7) " map:" --> (1455:3-1455:8) "\tmap:" -(2300:7-2301:2) " mapChildren,\n " --> (1455:8-1456:3) " mapChildren,\n\t\t" -(2301:2-2301:11) " forEach:" --> (1456:3-1456:12) "\tforEach:" -(2301:11-2302:2) " forEachChildren,\n " --> (1456:12-1457:3) " forEachChildren,\n\t\t" -(2302:2-2302:9) " count:" --> (1457:3-1457:10) "\tcount:" -(2302:9-2303:11) " countChildren,\n toArray:" --> (1457:10-1458:3) " countChildren,\n\t\t" -(2303:11-2304:2) " toArray,\n " --> (1458:3-1459:3) "\ttoArray,\n\t\t" -(2304:2-2304:8) " only:" --> (1459:3-1459:9) "\tonly:" -(2304:8-2305:1) " onlyChild\n" --> (1459:9-1460:2) " onlyChild\n\t" -(2305:1-2307:0) "};\n" --> (1460:2-1461:0) "\t};" -(2307:0-2307:8) "\nexports" --> (1461:0-1461:10) "\n\t\texports" -(2307:8-2307:19) ".Children =" --> (1461:10-1461:21) ".Children =" -(2307:19-2308:0) " Children;" --> (1461:21-1462:0) " Children;" -(2308:0-2308:8) "\nexports" --> (1462:0-1462:10) "\n\t\texports" -(2308:8-2308:20) ".Component =" --> (1462:10-1462:22) ".Component =" -(2308:20-2309:0) " Component;" --> (1462:22-1463:0) " Component;" -(2309:0-2309:8) "\nexports" --> (1463:0-1463:10) "\n\t\texports" -(2309:8-2309:24) ".PureComponent =" --> (1463:10-1463:26) ".PureComponent =" -(2309:24-2310:0) " PureComponent;" --> (1463:26-1464:0) " PureComponent;" -(2310:0-2310:8) "\nexports" --> (1464:0-1464:10) "\n\t\texports" -(2310:8-2310:61) ".__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =" --> (1464:10-1464:63) ".__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =" -(2310:61-2311:0) " ReactSharedInternals;" --> (1464:63-1465:0) " ReactSharedInternals;" -(2311:0-2311:8) "\nexports" --> (1465:0-1465:10) "\n\t\texports" -(2311:8-2311:23) ".cloneElement =" --> (1465:10-1465:25) ".cloneElement =" -(2311:23-2312:0) " cloneElement$1;" --> (1465:25-1466:0) " cloneElement$1;" -(2312:0-2312:8) "\nexports" --> (1466:0-1466:10) "\n\t\texports" -(2312:8-2312:24) ".createContext =" --> (1466:10-1466:26) ".createContext =" -(2312:24-2313:0) " createContext;" --> (1466:26-1467:0) " createContext;" -(2313:0-2313:8) "\nexports" --> (1467:0-1467:10) "\n\t\texports" -(2313:8-2313:24) ".createElement =" --> (1467:10-1467:26) ".createElement =" -(2313:24-2314:0) " createElement$1;" --> (1467:26-1468:0) " createElement$1;" -(2314:0-2314:8) "\nexports" --> (1468:0-1468:10) "\n\t\texports" -(2314:8-2314:24) ".createFactory =" --> (1468:10-1468:26) ".createFactory =" -(2314:24-2315:0) " createFactory;" --> (1468:26-1469:0) " createFactory;" -(2315:0-2315:8) "\nexports" --> (1469:0-1469:10) "\n\t\texports" -(2315:8-2315:20) ".createRef =" --> (1469:10-1469:22) ".createRef =" -(2315:20-2316:0) " createRef;" --> (1469:22-1470:0) " createRef;" -(2316:0-2316:8) "\nexports" --> (1470:0-1470:10) "\n\t\texports" -(2316:8-2316:21) ".forwardRef =" --> (1470:10-1470:23) ".forwardRef =" -(2316:21-2317:0) " forwardRef;" --> (1470:23-1471:0) " forwardRef;" -(2317:0-2317:8) "\nexports" --> (1471:0-1471:10) "\n\t\texports" -(2317:8-2317:25) ".isValidElement =" --> (1471:10-1471:27) ".isValidElement =" -(2317:25-2318:0) " isValidElement;" --> (1471:27-1472:0) " isValidElement;" -(2318:0-2318:8) "\nexports" --> (1472:0-1472:10) "\n\t\texports" -(2318:8-2318:15) ".lazy =" --> (1472:10-1472:17) ".lazy =" -(2318:15-2319:0) " lazy;" --> (1472:17-1473:0) " lazy;" -(2319:0-2319:8) "\nexports" --> (1473:0-1473:10) "\n\t\texports" -(2319:8-2319:15) ".memo =" --> (1473:10-1473:17) ".memo =" -(2319:15-2320:0) " memo;" --> (1473:17-1474:0) " memo;" -(2320:0-2320:8) "\nexports" --> (1474:0-1474:10) "\n\t\texports" -(2320:8-2320:22) ".useCallback =" --> (1474:10-1474:24) ".useCallback =" -(2320:22-2321:0) " useCallback;" --> (1474:24-1475:0) " useCallback;" -(2321:0-2321:8) "\nexports" --> (1475:0-1475:10) "\n\t\texports" -(2321:8-2321:21) ".useContext =" --> (1475:10-1475:23) ".useContext =" -(2321:21-2322:0) " useContext;" --> (1475:23-1476:0) " useContext;" -(2322:0-2322:8) "\nexports" --> (1476:0-1476:10) "\n\t\texports" -(2322:8-2322:24) ".useDebugValue =" --> (1476:10-1476:26) ".useDebugValue =" -(2322:24-2323:0) " useDebugValue;" --> (1476:26-1477:0) " useDebugValue;" -(2323:0-2323:8) "\nexports" --> (1477:0-1477:10) "\n\t\texports" -(2323:8-2323:20) ".useEffect =" --> (1477:10-1477:22) ".useEffect =" -(2323:20-2324:0) " useEffect;" --> (1477:22-1478:0) " useEffect;" -(2324:0-2324:8) "\nexports" --> (1478:0-1478:10) "\n\t\texports" -(2324:8-2324:30) ".useImperativeHandle =" --> (1478:10-1478:32) ".useImperativeHandle =" -(2324:30-2325:0) " useImperativeHandle;" --> (1478:32-1479:0) " useImperativeHandle;" -(2325:0-2325:8) "\nexports" --> (1479:0-1479:10) "\n\t\texports" -(2325:8-2325:26) ".useLayoutEffect =" --> (1479:10-1479:28) ".useLayoutEffect =" -(2325:26-2326:0) " useLayoutEffect;" --> (1479:28-1480:0) " useLayoutEffect;" -(2326:0-2326:8) "\nexports" --> (1480:0-1480:10) "\n\t\texports" -(2326:8-2326:18) ".useMemo =" --> (1480:10-1480:20) ".useMemo =" -(2326:18-2327:0) " useMemo;" --> (1480:20-1481:0) " useMemo;" -(2327:0-2327:8) "\nexports" --> (1481:0-1481:10) "\n\t\texports" -(2327:8-2327:21) ".useReducer =" --> (1481:10-1481:23) ".useReducer =" -(2327:21-2328:0) " useReducer;" --> (1481:23-1482:0) " useReducer;" -(2328:0-2328:8) "\nexports" --> (1482:0-1482:10) "\n\t\texports" -(2328:8-2328:17) ".useRef =" --> (1482:10-1482:19) ".useRef =" -(2328:17-2329:0) " useRef;" --> (1482:19-1483:0) " useRef;" -(2329:0-2329:8) "\nexports" --> (1483:0-1483:10) "\n\t\texports" -(2329:8-2329:19) ".useState =" --> (1483:10-1483:21) ".useState =" -(2329:19-2330:0) " useState;" --> (1483:21-1484:0) " useState;" -(2330:0-2330:8) "\nexports" --> (1484:0-1484:10) "\n\t\texports" -(2330:8-2330:18) ".version =" --> (1484:10-1484:20) ".version =" -(2330:18-2331:3) " ReactVersion;\n " --> (1484:20-1485:1) " ReactVersion;\n" -(2331:3-2331:6) "})(" --> (1485:1-1485:5) "\t})(" -(2331:6-2332:1) ");\n" --> (1485:5-1486:0) ");" -(2332:1-2333:1) "}\n" --> (1486:0-1487:1) "\n}\n" +(89:29-94:2) " {\n /**\n * @internal\n * @type {ReactComponent}\n */\n " --> (61:31-62:3) " {\n\t\t" +(94:2-94:11) " current:" --> (62:3-62:12) "\tcurrent:" +(94:11-95:1) " null\n" --> (62:12-63:2) " null\n\t" +(95:1-101:0) "};\n\n/**\n * Keeps track of the current batch's configuration such as how long an update\n * should suspend for if it needs to.\n */" --> (63:2-64:2) "\t};\n\t" +(101:0-101:4) "\nvar" --> (64:2-64:6) "\tvar" +(101:4-101:30) " ReactCurrentBatchConfig =" --> (64:6-64:32) " ReactCurrentBatchConfig =" +(101:30-102:2) " {\n " --> (64:32-65:3) " {\n\t\t" +(102:2-102:14) " transition:" --> (65:3-65:15) "\ttransition:" +(102:14-103:1) " 0\n" --> (65:15-66:2) " 0\n\t" +(103:1-111:0) "};\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n */" --> (66:2-67:2) "\t};\n\t" +(111:0-111:4) "\nvar" --> (67:2-67:6) "\tvar" +(111:4-111:24) " ReactCurrentOwner =" --> (67:6-67:26) " ReactCurrentOwner =" +(111:24-116:2) " {\n /**\n * @internal\n * @type {ReactComponent}\n */\n " --> (67:26-68:3) " {\n\t\t" +(116:2-116:11) " current:" --> (68:3-68:12) "\tcurrent:" +(116:11-117:1) " null\n" --> (68:12-69:2) " null\n\t" +(117:1-119:0) "};\n" --> (69:2-70:2) "\t};\n\t" +(119:0-119:4) "\nvar" --> (70:2-70:6) "\tvar" +(119:4-119:29) " ReactDebugCurrentFrame =" --> (70:6-70:31) " ReactDebugCurrentFrame =" +(119:29-119:31) " {" --> (70:31-70:32) " " +(119:31-120:0) "};" --> (70:32-71:2) "{};\n\t" +(120:0-120:4) "\nvar" --> (71:2-71:6) "\tvar" +(120:4-120:29) " currentExtraStackFrame =" --> (71:6-71:31) " currentExtraStackFrame =" +(120:29-121:0) " null;" --> (71:31-72:2) " null;\n\t" +(121:0-121:9) "\nfunction" --> (72:2-72:11) "\tfunction" +(121:9-121:28) " setExtraStackFrame" --> (72:11-72:30) " setExtraStackFrame" +(121:28-121:35) "(stack)" --> (72:30-72:37) "(stack)" +(121:35-122:2) " {\n " --> (72:37-73:3) " {\n\t\t" +(122:2-123:4) " {\n " --> (73:3-74:0) "\t{" +(123:4-123:29) " currentExtraStackFrame =" --> (74:0-74:29) "\n\t\t\t\tcurrentExtraStackFrame =" +(123:29-124:3) " stack;\n " --> (74:29-75:3) " stack;\n\t\t" +(124:3-125:1) "}\n" --> (75:3-76:2) "\t}\n\t" +(125:1-127:0) "}\n" --> (76:2-77:2) "\t}\n\t" +(127:0-128:2) "\n{\n " --> (77:2-78:0) "\t{" +(128:2-128:25) " ReactDebugCurrentFrame" --> (78:0-78:26) "\n\t\t\tReactDebugCurrentFrame" +(128:25-128:46) ".setExtraStackFrame =" --> (78:26-78:47) ".setExtraStackFrame =" +(128:46-128:56) " function " --> (78:47-78:56) " function" +(128:56-128:63) "(stack)" --> (78:56-78:63) "(stack)" +(128:63-129:4) " {\n " --> (78:63-79:4) " {\n\t\t\t" +(129:4-130:6) " {\n " --> (79:4-80:0) "\t{" +(130:6-130:31) " currentExtraStackFrame =" --> (80:0-80:30) "\n\t\t\t\t\tcurrentExtraStackFrame =" +(130:31-131:5) " stack;\n " --> (80:30-81:4) " stack;\n\t\t\t" +(131:5-132:3) "}\n " --> (81:4-82:3) "\t}\n\t\t" +(132:3-135:2) "}; // Stack implementation injected by the current renderer.\n\n\n " --> (82:3-83:0) "\t};" +(135:2-135:25) " ReactDebugCurrentFrame" --> (83:0-83:26) "\n\t\t\tReactDebugCurrentFrame" +(135:25-135:43) ".getCurrentStack =" --> (83:26-83:44) ".getCurrentStack =" +(135:43-137:2) " null;\n\n " --> (83:44-84:0) " null;" +(137:2-137:25) " ReactDebugCurrentFrame" --> (84:0-84:26) "\n\t\t\tReactDebugCurrentFrame" +(137:25-137:44) ".getStackAddendum =" --> (84:26-84:45) ".getStackAddendum =" +(137:44-137:56) " function ()" --> (84:45-84:56) " function()" +(137:56-138:4) " {\n " --> (84:56-85:4) " {\n\t\t\t" +(138:4-138:8) " var" --> (85:4-85:8) "\tvar" +(138:8-138:16) " stack =" --> (85:8-85:16) " stack =" +(138:16-140:4) " ''; // Add an extra top frame while an element is being validated\n\n " --> (85:16-86:0) " \"\";" +(140:4-140:8) " if " --> (86:0-86:8) "\n\t\t\t\tif " +(140:8-140:32) "(currentExtraStackFrame)" --> (86:8-86:32) "(currentExtraStackFrame)" +(140:32-141:6) " {\n " --> (86:32-87:0) " {" +(141:6-141:15) " stack +=" --> (87:0-87:14) "\n\t\t\t\t\tstack +=" +(141:15-142:5) " currentExtraStackFrame;\n " --> (87:14-88:4) " currentExtraStackFrame;\n\t\t\t" +(142:5-145:4) "} // Delegate to the injected renderer-specific implementation\n\n\n " --> (88:4-89:4) "\t}\n\t\t\t" +(145:4-145:8) " var" --> (89:4-89:8) "\tvar" +(145:8-145:15) " impl =" --> (89:8-89:15) " impl =" +(145:15-145:38) " ReactDebugCurrentFrame" --> (89:15-89:38) " ReactDebugCurrentFrame" +(145:38-147:4) ".getCurrentStack;\n\n " --> (89:38-90:0) ".getCurrentStack;" +(147:4-147:8) " if " --> (90:0-90:8) "\n\t\t\t\tif " +(147:8-147:14) "(impl)" --> (90:8-90:14) "(impl)" +(147:14-148:6) " {\n " --> (90:14-91:0) " {" +(148:6-148:15) " stack +=" --> (91:0-91:14) "\n\t\t\t\t\tstack +=" +(148:15-148:21) " impl(" --> (91:14-91:20) " impl(" +(148:21-148:25) ") ||" --> (91:20-91:24) ") ||" +(148:25-149:5) " '';\n " --> (91:24-92:4) " \"\";\n\t\t\t" +(149:5-151:4) "}\n\n " --> (92:4-93:0) "\t}" +(151:4-151:11) " return" --> (93:0-93:11) "\n\t\t\t\treturn" +(151:11-152:3) " stack;\n " --> (93:11-94:3) " stack;\n\t\t" +(152:3-153:1) "};\n" --> (94:3-95:2) "\t};\n\t" +(153:1-158:0) "}\n\n/**\n * Used by act() to track whether you're inside an act() scope.\n */" --> (95:2-96:2) "\t}\n\t" +(158:0-158:4) "\nvar" --> (96:2-96:6) "\tvar" +(158:4-158:27) " IsSomeRendererActing =" --> (96:6-96:29) " IsSomeRendererActing =" +(158:27-159:2) " {\n " --> (96:29-97:3) " {\n\t\t" +(159:2-159:11) " current:" --> (97:3-97:12) "\tcurrent:" +(159:11-160:1) " false\n" --> (97:12-98:2) " false\n\t" +(160:1-162:0) "};\n" --> (98:2-99:2) "\t};\n\t" +(162:0-162:4) "\nvar" --> (99:2-99:6) "\tvar" +(162:4-162:27) " ReactSharedInternals =" --> (99:6-99:29) " ReactSharedInternals =" +(162:27-163:26) " {\n ReactCurrentDispatcher:" --> (99:29-100:3) " {\n\t\t" +(163:26-164:27) " ReactCurrentDispatcher,\n ReactCurrentBatchConfig:" --> (100:3-101:3) "\tReactCurrentDispatcher,\n\t\t" +(164:27-165:21) " ReactCurrentBatchConfig,\n ReactCurrentOwner:" --> (101:3-102:3) "\tReactCurrentBatchConfig,\n\t\t" +(165:21-166:24) " ReactCurrentOwner,\n IsSomeRendererActing:" --> (102:3-103:3) "\tReactCurrentOwner,\n\t\t" +(166:24-168:2) " IsSomeRendererActing,\n // Used by renderers to avoid bundling object-assign twice in UMD bundles:\n " --> (103:3-104:3) "\tIsSomeRendererActing,\n\t\t" +(168:2-168:10) " assign:" --> (104:3-104:11) "\tassign:" +(168:10-169:1) " _assign\n" --> (104:11-105:2) " _assign\n\t" +(169:1-171:0) "};\n" --> (105:2-106:2) "\t};\n\t" +(171:0-172:2) "\n{\n " --> (106:2-107:0) "\t{" +(172:2-172:23) " ReactSharedInternals" --> (107:0-107:24) "\n\t\t\tReactSharedInternals" +(172:23-172:48) ".ReactDebugCurrentFrame =" --> (107:24-107:49) ".ReactDebugCurrentFrame =" +(172:48-173:1) " ReactDebugCurrentFrame;\n" --> (107:49-108:2) " ReactDebugCurrentFrame;\n\t" +(173:1-180:0) "}\n\n// by calls to these methods by a Babel plugin.\n//\n// In PROD (or in packages without access to React internals),\n// they are left as they are instead.\n" --> (108:2-109:2) "\t}\n\t" +(180:0-180:9) "\nfunction" --> (109:2-109:11) "\tfunction" +(180:9-180:14) " warn" --> (109:11-109:16) " warn" +(180:14-180:22) "(format)" --> (109:16-109:24) "(format)" +(180:22-181:2) " {\n " --> (109:24-110:3) " {\n\t\t" +(181:2-182:4) " {\n " --> (110:3-111:0) "\t{" +(182:4-182:9) " for " --> (111:0-111:9) "\n\t\t\t\tfor " +(182:9-182:13) "(var" --> (111:9-111:13) "(var" +(182:13-182:20) " _len =" --> (111:13-111:20) " _len =" +(182:20-182:30) " arguments" --> (111:20-111:30) " arguments" +(182:30-182:38) ".length," --> (111:30-111:38) ".length," +(182:38-182:45) " args =" --> (111:38-111:45) " args =" +(182:45-182:49) " new" --> (111:45-111:49) " new" +(182:49-182:55) " Array" --> (111:49-111:55) " Array" +(182:55-182:62) "(_len >" --> (111:55-111:62) "(_len >" +(182:62-182:66) " 1 ?" --> (111:62-111:66) " 1 ?" +(182:66-182:73) " _len -" --> (111:66-111:73) " _len -" +(182:73-182:77) " 1 :" --> (111:73-111:77) " 1 :" +(182:77-182:81) " 0)," --> (111:77-111:81) " 0)," +(182:81-182:88) " _key =" --> (111:81-111:88) " _key =" +(182:88-182:91) " 1;" --> (111:88-111:91) " 1;" +(182:91-182:98) " _key <" --> (111:91-111:98) " _key <" +(182:98-182:104) " _len;" --> (111:98-111:104) " _len;" +(182:104-182:112) " _key++)" --> (111:104-111:112) " _key++)" +(182:112-183:6) " {\n " --> (111:112-112:0) " {" +(183:6-183:11) " args" --> (112:0-112:10) "\n\t\t\t\t\targs" +(183:11-183:18) "[_key -" --> (112:10-112:17) "[_key -" +(183:18-183:23) " 1] =" --> (112:17-112:22) " 1] =" +(183:23-183:33) " arguments" --> (112:22-112:32) " arguments" +(183:33-184:5) "[_key];\n " --> (112:32-113:4) "[_key];\n\t\t\t" +(184:5-186:4) "}\n\n " --> (113:4-114:0) "\t}" +(186:4-186:17) " printWarning" --> (114:0-114:17) "\n\t\t\t\tprintWarning" +(186:17-186:25) "('warn'," --> (114:17-114:25) "(\"warn\"," +(186:25-186:33) " format," --> (114:25-114:33) " format," +(186:33-186:38) " args" --> (114:33-114:38) " args" +(186:38-187:3) ");\n " --> (114:38-115:3) ");\n\t\t" +(187:3-188:1) "}\n" --> (115:3-116:2) "\t}\n\t" +(188:1-189:0) "}" --> (116:2-117:2) "\t}\n\t" +(189:0-189:9) "\nfunction" --> (117:2-117:11) "\tfunction" +(189:9-189:15) " error" --> (117:11-117:17) " error" +(189:15-189:23) "(format)" --> (117:17-117:25) "(format)" +(189:23-190:2) " {\n " --> (117:25-118:3) " {\n\t\t" +(190:2-191:4) " {\n " --> (118:3-119:0) "\t{" +(191:4-191:9) " for " --> (119:0-119:9) "\n\t\t\t\tfor " +(191:9-191:13) "(var" --> (119:9-119:13) "(var" +(191:13-191:21) " _len2 =" --> (119:13-119:21) " _len2 =" +(191:21-191:31) " arguments" --> (119:21-119:31) " arguments" +(191:31-191:39) ".length," --> (119:31-119:39) ".length," +(191:39-191:46) " args =" --> (119:39-119:46) " args =" +(191:46-191:50) " new" --> (119:46-119:50) " new" +(191:50-191:56) " Array" --> (119:50-119:56) " Array" +(191:56-191:64) "(_len2 >" --> (119:56-119:64) "(_len2 >" +(191:64-191:68) " 1 ?" --> (119:64-119:68) " 1 ?" +(191:68-191:76) " _len2 -" --> (119:68-119:76) " _len2 -" +(191:76-191:80) " 1 :" --> (119:76-119:80) " 1 :" +(191:80-191:84) " 0)," --> (119:80-119:84) " 0)," +(191:84-191:92) " _key2 =" --> (119:84-119:92) " _key2 =" +(191:92-191:95) " 1;" --> (119:92-119:95) " 1;" +(191:95-191:103) " _key2 <" --> (119:95-119:103) " _key2 <" +(191:103-191:110) " _len2;" --> (119:103-119:110) " _len2;" +(191:110-191:119) " _key2++)" --> (119:110-119:119) " _key2++)" +(191:119-192:6) " {\n " --> (119:119-120:0) " {" +(192:6-192:11) " args" --> (120:0-120:10) "\n\t\t\t\t\targs" +(192:11-192:19) "[_key2 -" --> (120:10-120:18) "[_key2 -" +(192:19-192:24) " 1] =" --> (120:18-120:23) " 1] =" +(192:24-192:34) " arguments" --> (120:23-120:33) " arguments" +(192:34-193:5) "[_key2];\n " --> (120:33-121:4) "[_key2];\n\t\t\t" +(193:5-195:4) "}\n\n " --> (121:4-122:0) "\t}" +(195:4-195:17) " printWarning" --> (122:0-122:17) "\n\t\t\t\tprintWarning" +(195:17-195:26) "('error'," --> (122:17-122:26) "(\"error\"," +(195:26-195:34) " format," --> (122:26-122:34) " format," +(195:34-195:39) " args" --> (122:34-122:39) " args" +(195:39-196:3) ");\n " --> (122:39-123:3) ");\n\t\t" +(196:3-197:1) "}\n" --> (123:3-124:2) "\t}\n\t" +(197:1-199:0) "}\n" --> (124:2-125:2) "\t}\n\t" +(199:0-199:9) "\nfunction" --> (125:2-125:11) "\tfunction" +(199:9-199:22) " printWarning" --> (125:11-125:24) " printWarning" +(199:22-199:29) "(level," --> (125:24-125:31) "(level," +(199:29-199:37) " format," --> (125:31-125:39) " format," +(199:37-199:43) " args)" --> (125:39-125:45) " args)" +(199:43-202:2) " {\n // When changing this logic, you might want to also\n // update consoleWithStackDev.www.js as well.\n " --> (125:45-126:3) " {\n\t\t" +(202:2-203:4) " {\n " --> (126:3-127:4) "\t{\n\t\t\t" +(203:4-203:8) " var" --> (127:4-127:8) "\tvar" +(203:8-203:33) " ReactDebugCurrentFrame =" --> (127:8-127:33) " ReactDebugCurrentFrame =" +(203:33-203:54) " ReactSharedInternals" --> (127:33-127:54) " ReactSharedInternals" +(203:54-204:4) ".ReactDebugCurrentFrame;\n " --> (127:54-128:4) ".ReactDebugCurrentFrame;\n\t\t\t" +(204:4-204:8) " var" --> (128:4-128:8) "\tvar" +(204:8-204:16) " stack =" --> (128:8-128:16) " stack =" +(204:16-204:39) " ReactDebugCurrentFrame" --> (128:16-128:39) " ReactDebugCurrentFrame" +(204:39-204:57) ".getStackAddendum(" --> (128:39-128:57) ".getStackAddendum(" +(204:57-206:4) ");\n\n " --> (128:57-129:0) ");" +(206:4-206:8) " if " --> (129:0-129:8) "\n\t\t\t\tif " +(206:8-206:18) "(stack !==" --> (129:8-129:18) "(stack !==" +(206:18-206:22) " '')" --> (129:18-129:22) " \"\")" +(206:22-207:6) " {\n " --> (129:22-130:0) " {" +(207:6-207:16) " format +=" --> (130:0-130:15) "\n\t\t\t\t\tformat +=" +(207:16-208:6) " '%s';\n " --> (130:15-131:0) " \"%s\";" +(208:6-208:13) " args =" --> (131:0-131:12) "\n\t\t\t\t\targs =" +(208:13-208:18) " args" --> (131:12-131:17) " args" +(208:18-208:25) ".concat" --> (131:17-131:24) ".concat" +(208:25-208:26) "(" --> (131:24-131:25) "(" +(208:26-208:32) "[stack" --> (131:25-131:31) "[stack" +(208:32-208:33) "]" --> (131:31-131:32) "]" +(208:33-209:5) ");\n " --> (131:32-132:4) ");\n\t\t\t" +(209:5-211:4) "}\n\n " --> (132:4-133:4) "\t}\n\t\t\t" +(211:4-211:8) " var" --> (133:4-133:8) "\tvar" +(211:8-211:25) " argsWithFormat =" --> (133:8-133:25) " argsWithFormat =" +(211:25-211:30) " args" --> (133:25-133:30) " args" +(211:30-211:34) ".map" --> (133:30-133:34) ".map" +(211:34-211:44) "(function " --> (133:34-133:43) "(function" +(211:44-211:50) "(item)" --> (133:43-133:49) "(item)" +(211:50-212:6) " {\n " --> (133:49-134:0) " {" +(212:6-212:13) " return" --> (134:0-134:12) "\n\t\t\t\t\treturn" +(212:13-212:18) " '' +" --> (134:12-134:17) " \"\" +" +(212:18-213:5) " item;\n " --> (134:17-135:4) " item;\n\t\t\t" +(213:5-213:6) "}" --> (135:4-135:6) "\t}" +(213:6-215:4) "); // Careful: RN currently depends on this prefix\n\n " --> (135:6-136:0) ");" +(215:4-215:19) " argsWithFormat" --> (136:0-136:19) "\n\t\t\t\targsWithFormat" +(215:19-215:27) ".unshift" --> (136:19-136:27) ".unshift" +(215:27-215:41) "('Warning: ' +" --> (136:27-136:41) "(\"Warning: \" +" +(215:41-215:48) " format" --> (136:41-136:48) " format" +(215:48-219:4) "); // We intentionally don't use spread (or .apply) directly because it\n // breaks IE9: https://github.com/facebook/react/issues/13610\n // eslint-disable-next-line react-internal/no-production-logging\n\n " --> (136:48-137:0) ");" +(219:4-219:13) " Function" --> (137:0-137:13) "\n\t\t\t\tFunction" +(219:13-219:23) ".prototype" --> (137:13-137:23) ".prototype" +(219:23-219:29) ".apply" --> (137:23-137:29) ".apply" +(219:29-219:34) ".call" --> (137:29-137:34) ".call" +(219:34-219:42) "(console" --> (137:34-137:42) "(console" +(219:42-219:50) "[level]," --> (137:42-137:50) "[level]," +(219:50-219:59) " console," --> (137:50-137:59) " console," +(219:59-219:74) " argsWithFormat" --> (137:59-137:74) " argsWithFormat" +(219:74-220:3) ");\n " --> (137:74-138:3) ");\n\t\t" +(220:3-221:1) "}\n" --> (138:3-139:2) "\t}\n\t" +(221:1-223:0) "}\n" --> (139:2-140:2) "\t}\n\t" +(223:0-223:4) "\nvar" --> (140:2-140:6) "\tvar" +(223:4-223:46) " didWarnStateUpdateForUnmountedComponent =" --> (140:6-140:48) " didWarnStateUpdateForUnmountedComponent =" +(223:46-223:48) " {" --> (140:48-140:49) " " +(223:48-225:0) "};\n" --> (140:49-141:2) "{};\n\t" +(225:0-225:9) "\nfunction" --> (141:2-141:11) "\tfunction" +(225:9-225:18) " warnNoop" --> (141:11-141:20) " warnNoop" +(225:18-225:34) "(publicInstance," --> (141:20-141:36) "(publicInstance," +(225:34-225:46) " callerName)" --> (141:36-141:48) " callerName)" +(225:46-226:2) " {\n " --> (141:48-142:3) " {\n\t\t" +(226:2-227:4) " {\n " --> (142:3-143:4) "\t{\n\t\t\t" +(227:4-227:8) " var" --> (143:4-143:8) "\tvar" +(227:8-227:23) " _constructor =" --> (143:8-143:23) " _constructor =" +(227:23-227:38) " publicInstance" --> (143:23-143:38) " publicInstance" +(227:38-228:4) ".constructor;\n " --> (143:38-144:4) ".constructor;\n\t\t\t" +(228:4-228:8) " var" --> (144:4-144:8) "\tvar" +(228:8-228:24) " componentName =" --> (144:8-144:24) " componentName =" +(228:24-228:41) " _constructor && " --> (144:24-144:41) " _constructor && " +(228:41-228:54) "(_constructor" --> (144:41-144:54) "(_constructor" +(228:54-228:69) ".displayName ||" --> (144:54-144:69) ".displayName ||" +(228:69-228:82) " _constructor" --> (144:69-144:82) " _constructor" +(228:82-228:91) ".name) ||" --> (144:82-144:91) ".name) ||" +(228:91-229:4) " 'ReactClass';\n " --> (144:91-145:4) " \"ReactClass\";\n\t\t\t" +(229:4-229:8) " var" --> (145:4-145:8) "\tvar" +(229:8-229:21) " warningKey =" --> (145:8-145:21) " warningKey =" +(229:21-229:37) " componentName +" --> (145:21-145:37) " componentName +" +(229:37-229:43) " \".\" +" --> (145:37-145:43) " \".\" +" +(229:43-231:4) " callerName;\n\n " --> (145:43-146:0) " callerName;" +(231:4-231:8) " if " --> (146:0-146:8) "\n\t\t\t\tif " +(231:8-231:48) "(didWarnStateUpdateForUnmountedComponent" --> (146:8-146:48) "(didWarnStateUpdateForUnmountedComponent" +(231:48-231:61) "[warningKey])" --> (146:48-146:61) "[warningKey])" +(231:61-232:6) " {\n " --> (146:61-147:0) " {" +(232:6-233:5) " return;\n " --> (147:0-148:4) "\n\t\t\t\t\treturn;\n\t\t\t" +(233:5-235:4) "}\n\n " --> (148:4-149:0) "\t}" +(235:4-235:10) " error" --> (149:0-149:10) "\n\t\t\t\terror" +(235:10-235:69) "(\"Can't call %s on a component that is not yet mounted. \" +" --> (149:10-149:69) "(\"Can't call %s on a component that is not yet mounted. \" +" +(235:69-235:140) " 'This is a no-op, but it might indicate a bug in your application. ' +" --> (149:69-149:140) " \"This is a no-op, but it might indicate a bug in your application. \" +" +(235:140-235:212) " 'Instead, assign to `this.state` directly or define a `state = {};` ' +" --> (149:140-149:212) " \"Instead, assign to `this.state` directly or define a `state = {};` \" +" +(235:212-235:274) " 'class property with the desired state in the %s component.'," --> (149:212-149:274) " \"class property with the desired state in the %s component.\"," +(235:274-235:286) " callerName," --> (149:274-149:286) " callerName," +(235:286-235:300) " componentName" --> (149:286-149:300) " componentName" +(235:300-237:4) ");\n\n " --> (149:300-150:0) ");" +(237:4-237:44) " didWarnStateUpdateForUnmountedComponent" --> (150:0-150:44) "\n\t\t\t\tdidWarnStateUpdateForUnmountedComponent" +(237:44-237:58) "[warningKey] =" --> (150:44-150:58) "[warningKey] =" +(237:58-238:3) " true;\n " --> (150:58-151:3) " true;\n\t\t" +(238:3-239:1) "}\n" --> (151:3-152:2) "\t}\n\t" +(239:1-245:0) "}\n/**\n * This is the abstract API for an update queue.\n */\n\n" --> (152:2-153:2) "\t}\n\t" +(245:0-245:4) "\nvar" --> (153:2-153:6) "\tvar" +(245:4-245:27) " ReactNoopUpdateQueue =" --> (153:6-153:29) " ReactNoopUpdateQueue =" +(245:27-253:2) " {\n /**\n * Checks whether or not this composite component is mounted.\n * @param {ReactClass} publicInstance The instance we want to test.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n " --> (153:29-154:3) " {\n\t\t" +(253:2-253:13) " isMounted:" --> (154:3-154:14) "\tisMounted:" +(253:13-253:23) " function " --> (154:14-154:23) " function" +(253:23-253:39) "(publicInstance)" --> (154:23-154:39) "(publicInstance)" +(253:39-254:4) " {\n " --> (154:39-155:0) " {" +(254:4-254:11) " return" --> (155:0-155:11) "\n\t\t\t\treturn" +(254:11-255:3) " false;\n " --> (155:11-156:3) " false;\n\t\t" +(255:3-272:2) "},\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {?function} callback Called after component is updated.\n * @param {?string} callerName name of the calling function in the public API.\n * @internal\n */\n " --> (156:3-157:3) "\t},\n\t\t" +(272:2-272:22) " enqueueForceUpdate:" --> (157:3-157:23) "\tenqueueForceUpdate:" +(272:22-272:32) " function " --> (157:23-157:32) " function" +(272:32-272:48) "(publicInstance," --> (157:32-157:48) "(publicInstance," +(272:48-272:58) " callback," --> (157:48-157:58) " callback," +(272:58-272:70) " callerName)" --> (157:58-157:70) " callerName)" +(272:70-273:4) " {\n " --> (157:70-158:0) " {" +(273:4-273:13) " warnNoop" --> (158:0-158:13) "\n\t\t\t\twarnNoop" +(273:13-273:29) "(publicInstance," --> (158:13-158:29) "(publicInstance," +(273:29-273:43) " 'forceUpdate'" --> (158:29-158:43) " \"forceUpdate\"" +(273:43-274:3) ");\n " --> (158:43-159:3) ");\n\t\t" +(274:3-289:2) "},\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @param {?function} callback Called after component is updated.\n * @param {?string} callerName name of the calling function in the public API.\n * @internal\n */\n " --> (159:3-160:3) "\t},\n\t\t" +(289:2-289:23) " enqueueReplaceState:" --> (160:3-160:24) "\tenqueueReplaceState:" +(289:23-289:33) " function " --> (160:24-160:33) " function" +(289:33-289:49) "(publicInstance," --> (160:33-160:49) "(publicInstance," +(289:49-289:64) " completeState," --> (160:49-160:64) " completeState," +(289:64-289:74) " callback," --> (160:64-160:74) " callback," +(289:74-289:86) " callerName)" --> (160:74-160:86) " callerName)" +(289:86-290:4) " {\n " --> (160:86-161:0) " {" +(290:4-290:13) " warnNoop" --> (161:0-161:13) "\n\t\t\t\twarnNoop" +(290:13-290:29) "(publicInstance," --> (161:13-161:29) "(publicInstance," +(290:29-290:44) " 'replaceState'" --> (161:29-161:44) " \"replaceState\"" +(290:44-291:3) ");\n " --> (161:44-162:3) ");\n\t\t" +(291:3-305:2) "},\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @param {?function} callback Called after component is updated.\n * @param {?string} Name of the calling function in the public API.\n * @internal\n */\n " --> (162:3-163:3) "\t},\n\t\t" +(305:2-305:19) " enqueueSetState:" --> (163:3-163:20) "\tenqueueSetState:" +(305:19-305:29) " function " --> (163:20-163:29) " function" +(305:29-305:45) "(publicInstance," --> (163:29-163:45) "(publicInstance," +(305:45-305:59) " partialState," --> (163:45-163:59) " partialState," +(305:59-305:69) " callback," --> (163:59-163:69) " callback," +(305:69-305:81) " callerName)" --> (163:69-163:81) " callerName)" +(305:81-306:4) " {\n " --> (163:81-164:0) " {" +(306:4-306:13) " warnNoop" --> (164:0-164:13) "\n\t\t\t\twarnNoop" +(306:13-306:29) "(publicInstance," --> (164:13-164:29) "(publicInstance," +(306:29-306:40) " 'setState'" --> (164:29-164:40) " \"setState\"" +(306:40-307:3) ");\n " --> (164:40-165:3) ");\n\t\t" +(307:3-308:1) "}\n" --> (165:3-166:2) "\t}\n\t" +(308:1-310:0) "};\n" --> (166:2-167:2) "\t};\n\t" +(310:0-310:4) "\nvar" --> (167:2-167:6) "\tvar" +(310:4-310:18) " emptyObject =" --> (167:6-167:20) " emptyObject =" +(310:18-310:20) " {" --> (167:20-167:21) " " +(310:20-312:0) "};\n" --> (167:21-168:2) "{};\n\t" +(312:0-313:2) "\n{\n " --> (168:2-169:0) "\t{" +(313:2-313:9) " Object" --> (169:0-169:10) "\n\t\t\tObject" +(313:9-313:16) ".freeze" --> (169:10-169:17) ".freeze" +(313:16-313:28) "(emptyObject" --> (169:17-169:29) "(emptyObject" +(313:28-314:1) ");\n" --> (169:29-170:2) ");\n\t" +(314:1-320:0) "}\n/**\n * Base class helpers for the updating state of a component.\n */\n\n" --> (170:2-171:2) "\t}\n\t" +(320:0-320:9) "\nfunction" --> (171:2-171:11) "\tfunction" +(320:9-320:19) " Component" --> (171:11-171:21) " Component" +(320:19-320:26) "(props," --> (171:21-171:28) "(props," +(320:26-320:35) " context," --> (171:28-171:37) " context," +(320:35-320:44) " updater)" --> (171:37-171:46) " updater)" +(320:44-321:2) " {\n " --> (171:46-172:0) " {" +(321:2-321:7) " this" --> (172:0-172:8) "\n\t\t\tthis" +(321:7-321:15) ".props =" --> (172:8-172:16) ".props =" +(321:15-322:2) " props;\n " --> (172:16-173:0) " props;" +(322:2-322:7) " this" --> (173:0-173:8) "\n\t\t\tthis" +(322:7-322:17) ".context =" --> (173:8-173:18) ".context =" +(322:17-324:2) " context; // If a component has string refs, we will assign a different object later.\n\n " --> (173:18-174:0) " context;" +(324:2-324:7) " this" --> (174:0-174:8) "\n\t\t\tthis" +(324:7-324:14) ".refs =" --> (174:8-174:15) ".refs =" +(324:14-327:2) " emptyObject; // We initialize the default updater but the real one gets injected by the\n // renderer.\n\n " --> (174:15-175:0) " emptyObject;" +(327:2-327:7) " this" --> (175:0-175:8) "\n\t\t\tthis" +(327:7-327:17) ".updater =" --> (175:8-175:18) ".updater =" +(327:17-327:28) " updater ||" --> (175:18-175:29) " updater ||" +(327:28-328:1) " ReactNoopUpdateQueue;\n" --> (175:29-176:2) " ReactNoopUpdateQueue;\n\t" +(328:1-330:0) "}\n" --> (176:2-177:0) "\t}" +(330:0-330:10) "\nComponent" --> (177:0-177:12) "\n\t\tComponent" +(330:10-330:20) ".prototype" --> (177:12-177:22) ".prototype" +(330:20-330:39) ".isReactComponent =" --> (177:22-177:41) ".isReactComponent =" +(330:39-330:41) " {" --> (177:41-177:42) " " +(330:41-357:0) "};\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together. You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n * produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\n" --> (177:42-178:0) "{};" +(357:0-357:10) "\nComponent" --> (178:0-178:12) "\n\t\tComponent" +(357:10-357:20) ".prototype" --> (178:12-178:22) ".prototype" +(357:20-357:31) ".setState =" --> (178:22-178:33) ".setState =" +(357:31-357:41) " function " --> (178:33-178:42) " function" +(357:41-357:55) "(partialState," --> (178:42-178:56) "(partialState," +(357:55-357:65) " callback)" --> (178:56-178:66) " callback)" +(357:65-358:2) " {\n " --> (178:66-179:0) " {" +(358:2-358:15) " if (!(typeof" --> (179:0-179:16) "\n\t\t\tif (!(typeof" +(358:15-358:32) " partialState ===" --> (179:16-179:33) " partialState ===" +(358:32-358:51) " 'object' || typeof" --> (179:33-179:52) " \"object\" || typeof" +(358:51-358:68) " partialState ===" --> (179:52-179:69) " partialState ===" +(358:68-358:82) " 'function' ||" --> (179:69-179:83) " \"function\" ||" +(358:82-358:98) " partialState ==" --> (179:83-179:99) " partialState ==" +(358:98-358:105) " null))" --> (179:99-179:106) " null))" +(358:105-359:4) " {\n " --> (179:106-180:4) " {\n\t\t\t" +(359:4-360:6) " {\n " --> (180:4-181:0) "\t{" +(360:6-360:12) " throw" --> (181:0-181:11) "\n\t\t\t\t\tthrow" +(360:12-360:19) " Error(" --> (181:11-181:17) " Error" +(360:19-360:140) " \"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\" " --> (181:17-181:137) "(\"setState(...): takes an object of state variables to update or a function which returns an object of state variables.\"" +(360:140-361:5) ");\n " --> (181:137-182:4) ");\n\t\t\t" +(361:5-362:3) "}\n " --> (182:4-183:3) "\t}\n\t\t" +(362:3-364:2) "}\n\n " --> (183:3-184:0) "\t}" +(364:2-364:7) " this" --> (184:0-184:8) "\n\t\t\tthis" +(364:7-364:15) ".updater" --> (184:8-184:16) ".updater" +(364:15-364:31) ".enqueueSetState" --> (184:16-184:32) ".enqueueSetState" +(364:31-364:37) "(this," --> (184:32-184:38) "(this," +(364:37-364:51) " partialState," --> (184:38-184:52) " partialState," +(364:51-364:61) " callback," --> (184:52-184:62) " callback," +(364:61-364:72) " 'setState'" --> (184:62-184:73) " \"setState\"" +(364:72-365:1) ");\n" --> (184:73-185:2) ");\n\t" +(365:1-382:0) "};\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\n\n" --> (185:2-186:0) "\t};" +(382:0-382:10) "\nComponent" --> (186:0-186:12) "\n\t\tComponent" +(382:10-382:20) ".prototype" --> (186:12-186:22) ".prototype" +(382:20-382:34) ".forceUpdate =" --> (186:22-186:36) ".forceUpdate =" +(382:34-382:44) " function " --> (186:36-186:45) " function" +(382:44-382:54) "(callback)" --> (186:45-186:55) "(callback)" +(382:54-383:2) " {\n " --> (186:55-187:0) " {" +(383:2-383:7) " this" --> (187:0-187:8) "\n\t\t\tthis" +(383:7-383:15) ".updater" --> (187:8-187:16) ".updater" +(383:15-383:34) ".enqueueForceUpdate" --> (187:16-187:35) ".enqueueForceUpdate" +(383:34-383:40) "(this," --> (187:35-187:41) "(this," +(383:40-383:50) " callback," --> (187:41-187:51) " callback," +(383:50-383:64) " 'forceUpdate'" --> (187:51-187:65) " \"forceUpdate\"" +(383:64-384:1) ");\n" --> (187:65-188:2) ");\n\t" +(384:1-392:0) "};\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\n\n" --> (188:2-189:2) "\t};\n\t" +(392:0-393:2) "\n{\n " --> (189:2-190:3) "\t{\n\t\t" +(393:2-393:6) " var" --> (190:3-190:7) "\tvar" +(393:6-393:23) " deprecatedAPIs =" --> (190:7-190:24) " deprecatedAPIs =" +(393:23-394:4) " {\n " --> (190:24-191:4) " {\n\t\t\t" +(394:4-394:15) " isMounted:" --> (191:4-191:15) "\tisMounted:" +(394:15-394:16) " " --> (191:15-191:16) " " +(394:16-394:29) "['isMounted'," --> (191:16-191:29) "[\"isMounted\"," +(394:29-394:103) " 'Instead, make sure to clean up subscriptions and pending requests in ' +" --> (191:29-191:103) " \"Instead, make sure to clean up subscriptions and pending requests in \" +" +(394:103-394:151) " 'componentWillUnmount to prevent memory leaks.'" --> (191:103-191:151) " \"componentWillUnmount to prevent memory leaks.\"" +(394:151-395:4) "],\n " --> (191:151-192:4) "],\n\t\t\t" +(395:4-395:18) " replaceState:" --> (192:4-192:18) "\treplaceState:" +(395:18-395:19) " " --> (192:18-192:19) " " +(395:19-395:35) "['replaceState'," --> (192:19-192:35) "[\"replaceState\"," +(395:35-395:88) " 'Refactor your code to use setState instead (see ' +" --> (192:35-192:88) " \"Refactor your code to use setState instead (see \" +" +(395:88-395:138) " 'https://github.com/facebook/react/issues/3236).'" --> (192:88-192:138) " \"https://github.com/facebook/react/issues/3236).\"" +(395:138-396:3) "]\n " --> (192:138-193:3) "]\n\t\t" +(396:3-398:2) "};\n\n " --> (193:3-194:3) "\t};\n\t\t" +(398:2-398:6) " var" --> (194:3-194:7) "\tvar" +(398:6-398:33) " defineDeprecationWarning =" --> (194:7-194:34) " defineDeprecationWarning =" +(398:33-398:43) " function " --> (194:34-194:43) " function" +(398:43-398:55) "(methodName," --> (194:43-194:55) "(methodName," +(398:55-398:61) " info)" --> (194:55-194:61) " info)" +(398:61-399:4) " {\n " --> (194:61-195:0) " {" +(399:4-399:11) " Object" --> (195:0-195:11) "\n\t\t\t\tObject" +(399:11-399:26) ".defineProperty" --> (195:11-195:26) ".defineProperty" +(399:26-399:36) "(Component" --> (195:26-195:36) "(Component" +(399:36-399:47) ".prototype," --> (195:36-195:47) ".prototype," +(399:47-399:59) " methodName," --> (195:47-195:59) " methodName," +(399:59-400:6) " {\n " --> (195:59-196:5) " {\n\t\t\t\t" +(400:6-400:11) " get:" --> (196:5-196:10) "\tget:" +(400:11-400:23) " function ()" --> (196:10-196:21) " function()" +(400:23-401:8) " {\n " --> (196:21-197:0) " {" +(401:8-401:13) " warn" --> (197:0-197:11) "\n\t\t\t\t\t\twarn" +(401:13-401:76) "('%s(...) is deprecated in plain JavaScript React classes. %s'," --> (197:11-197:74) "(\"%s(...) is deprecated in plain JavaScript React classes. %s\"," +(401:76-401:81) " info" --> (197:74-197:79) " info" +(401:81-401:85) "[0]," --> (197:79-197:83) "[0]," +(401:85-401:90) " info" --> (197:83-197:88) " info" +(401:90-401:93) "[1]" --> (197:88-197:91) "[1]" +(401:93-403:8) ");\n\n " --> (197:91-198:0) ");" +(403:8-403:15) " return" --> (198:0-198:13) "\n\t\t\t\t\t\treturn" +(403:15-404:7) " undefined;\n " --> (198:13-199:5) " undefined;\n\t\t\t\t" +(404:7-405:5) "}\n " --> (199:5-200:4) "\t}\n\t\t\t" +(405:5-405:6) "}" --> (200:4-200:6) "\t}" +(405:6-406:3) ");\n " --> (200:6-201:3) ");\n\t\t" +(406:3-408:2) "};\n\n " --> (201:3-202:0) "\t};" +(408:2-408:7) " for " --> (202:0-202:8) "\n\t\t\tfor " +(408:7-408:11) "(var" --> (202:8-202:12) "(var" +(408:11-408:21) " fnName in" --> (202:12-202:22) " fnName in" +(408:21-408:37) " deprecatedAPIs)" --> (202:22-202:38) " deprecatedAPIs)" +(408:37-409:4) " {\n " --> (202:38-203:0) " {" +(409:4-409:8) " if " --> (203:0-203:8) "\n\t\t\t\tif " +(409:8-409:23) "(deprecatedAPIs" --> (203:8-203:23) "(deprecatedAPIs" +(409:23-409:38) ".hasOwnProperty" --> (203:23-203:38) ".hasOwnProperty" +(409:38-409:45) "(fnName" --> (203:38-203:45) "(fnName" +(409:45-409:47) "))" --> (203:45-203:47) "))" +(409:47-410:6) " {\n " --> (203:47-204:0) " {" +(410:6-410:31) " defineDeprecationWarning" --> (204:0-204:30) "\n\t\t\t\t\tdefineDeprecationWarning" +(410:31-410:39) "(fnName," --> (204:30-204:38) "(fnName," +(410:39-410:54) " deprecatedAPIs" --> (204:38-204:53) " deprecatedAPIs" +(410:54-410:62) "[fnName]" --> (204:53-204:61) "[fnName]" +(410:62-411:5) ");\n " --> (204:61-205:4) ");\n\t\t\t" +(411:5-412:3) "}\n " --> (205:4-206:3) "\t}\n\t\t" +(412:3-413:1) "}\n" --> (206:3-207:2) "\t}\n\t" +(413:1-415:0) "}\n" --> (207:2-208:2) "\t}\n\t" +(415:0-415:9) "\nfunction" --> (208:2-208:11) "\tfunction" +(415:9-415:26) " ComponentDummy()" --> (208:11-208:28) " ComponentDummy()" +(415:26-415:28) " {" --> (208:28-208:29) " " +(415:28-417:0) "}\n" --> (208:29-209:0) "{}" +(417:0-417:15) "\nComponentDummy" --> (209:0-209:17) "\n\t\tComponentDummy" +(417:15-417:27) ".prototype =" --> (209:17-209:29) ".prototype =" +(417:27-417:37) " Component" --> (209:29-209:39) " Component" +(417:37-422:0) ".prototype;\n/**\n * Convenience component with default shallow equality check for sCU.\n */\n" --> (209:39-210:2) ".prototype;\n\t" +(422:0-422:9) "\nfunction" --> (210:2-210:11) "\tfunction" +(422:9-422:23) " PureComponent" --> (210:11-210:25) " PureComponent" +(422:23-422:30) "(props," --> (210:25-210:32) "(props," +(422:30-422:39) " context," --> (210:32-210:41) " context," +(422:39-422:48) " updater)" --> (210:41-210:50) " updater)" +(422:48-423:2) " {\n " --> (210:50-211:0) " {" +(423:2-423:7) " this" --> (211:0-211:8) "\n\t\t\tthis" +(423:7-423:15) ".props =" --> (211:8-211:16) ".props =" +(423:15-424:2) " props;\n " --> (211:16-212:0) " props;" +(424:2-424:7) " this" --> (212:0-212:8) "\n\t\t\tthis" +(424:7-424:17) ".context =" --> (212:8-212:18) ".context =" +(424:17-426:2) " context; // If a component has string refs, we will assign a different object later.\n\n " --> (212:18-213:0) " context;" +(426:2-426:7) " this" --> (213:0-213:8) "\n\t\t\tthis" +(426:7-426:14) ".refs =" --> (213:8-213:15) ".refs =" +(426:14-427:2) " emptyObject;\n " --> (213:15-214:0) " emptyObject;" +(427:2-427:7) " this" --> (214:0-214:8) "\n\t\t\tthis" +(427:7-427:17) ".updater =" --> (214:8-214:18) ".updater =" +(427:17-427:28) " updater ||" --> (214:18-214:29) " updater ||" +(427:28-428:1) " ReactNoopUpdateQueue;\n" --> (214:29-215:2) " ReactNoopUpdateQueue;\n\t" +(428:1-430:0) "}\n" --> (215:2-216:2) "\t}\n\t" +(430:0-430:4) "\nvar" --> (216:2-216:6) "\tvar" +(430:4-430:29) " pureComponentPrototype =" --> (216:6-216:31) " pureComponentPrototype =" +(430:29-430:43) " PureComponent" --> (216:31-216:45) " PureComponent" +(430:43-430:55) ".prototype =" --> (216:45-216:57) ".prototype =" +(430:55-430:59) " new" --> (216:57-216:61) " new" +(430:59-431:0) " ComponentDummy();" --> (216:61-217:0) " ComponentDummy();" +(431:0-431:23) "\npureComponentPrototype" --> (217:0-217:25) "\n\t\tpureComponentPrototype" +(431:23-431:37) ".constructor =" --> (217:25-217:39) ".constructor =" +(431:37-433:0) " PureComponent; // Avoid an extra prototype jump for these methods.\n" --> (217:39-218:0) " PureComponent;" +(433:0-433:8) "\n_assign" --> (218:0-218:10) "\n\t\t_assign" +(433:8-433:32) "(pureComponentPrototype," --> (218:10-218:34) "(pureComponentPrototype," +(433:32-433:42) " Component" --> (218:34-218:44) " Component" +(433:42-433:52) ".prototype" --> (218:44-218:54) ".prototype" +(433:52-435:0) ");\n" --> (218:54-219:0) ");" +(435:0-435:23) "\npureComponentPrototype" --> (219:0-219:25) "\n\t\tpureComponentPrototype" +(435:23-435:46) ".isPureReactComponent =" --> (219:25-219:48) ".isPureReactComponent =" +(435:46-438:0) " true;\n\n// an immutable object with a single mutable value" --> (219:48-220:2) " true;\n\t" +(438:0-438:9) "\nfunction" --> (220:2-220:11) "\tfunction" +(438:9-438:21) " createRef()" --> (220:11-220:23) " createRef()" +(438:21-439:2) " {\n " --> (220:23-221:3) " {\n\t\t" +(439:2-439:6) " var" --> (221:3-221:7) "\tvar" +(439:6-439:18) " refObject =" --> (221:7-221:19) " refObject =" +(439:18-440:4) " {\n " --> (221:19-222:4) " {\n\t\t\t" +(440:4-440:13) " current:" --> (222:4-222:13) "\tcurrent:" +(440:13-441:3) " null\n " --> (222:13-223:3) " null\n\t\t" +(441:3-443:2) "};\n\n " --> (223:3-224:3) "\t};\n\t\t" +(443:2-444:4) " {\n " --> (224:3-225:0) "\t{" +(444:4-444:11) " Object" --> (225:0-225:11) "\n\t\t\t\tObject" +(444:11-444:16) ".seal" --> (225:11-225:16) ".seal" +(444:16-444:26) "(refObject" --> (225:16-225:26) "(refObject" +(444:26-445:3) ");\n " --> (225:26-226:3) ");\n\t\t" +(445:3-447:2) "}\n\n " --> (226:3-227:0) "\t}" +(447:2-447:9) " return" --> (227:0-227:10) "\n\t\t\treturn" +(447:9-448:1) " refObject;\n" --> (227:10-228:2) " refObject;\n\t" +(448:1-450:0) "}\n" --> (228:2-229:2) "\t}\n\t" +(450:0-450:9) "\nfunction" --> (229:2-229:11) "\tfunction" +(450:9-450:24) " getWrappedName" --> (229:11-229:26) " getWrappedName" +(450:24-450:35) "(outerType," --> (229:26-229:37) "(outerType," +(450:35-450:46) " innerType," --> (229:37-229:48) " innerType," +(450:46-450:59) " wrapperName)" --> (229:48-229:61) " wrapperName)" +(450:59-451:2) " {\n " --> (229:61-230:3) " {\n\t\t" +(451:2-451:6) " var" --> (230:3-230:7) "\tvar" +(451:6-451:21) " functionName =" --> (230:7-230:22) " functionName =" +(451:21-451:31) " innerType" --> (230:22-230:32) " innerType" +(451:31-451:46) ".displayName ||" --> (230:32-230:47) ".displayName ||" +(451:46-451:56) " innerType" --> (230:47-230:57) " innerType" +(451:56-451:64) ".name ||" --> (230:57-230:65) ".name ||" +(451:64-452:2) " '';\n " --> (230:65-231:0) " \"\";" +(452:2-452:9) " return" --> (231:0-231:10) "\n\t\t\treturn" +(452:9-452:19) " outerType" --> (231:10-231:20) " outerType" +(452:19-452:35) ".displayName || " --> (231:20-231:36) ".displayName || " +(452:35-452:52) "(functionName !==" --> (231:36-231:53) "(functionName !==" +(452:52-452:57) " '' ?" --> (231:53-231:58) " \"\" ?" +(452:57-452:71) " wrapperName +" --> (231:58-231:72) " wrapperName +" +(452:71-452:77) " \"(\" +" --> (231:72-231:78) " \"(\" +" +(452:77-452:92) " functionName +" --> (231:78-231:93) " functionName +" +(452:92-452:98) " \")\" :" --> (231:93-231:99) " \")\" :" +(452:98-453:1) " wrapperName);\n" --> (231:99-232:2) " wrapperName);\n\t" +(453:1-455:0) "}\n" --> (232:2-233:2) "\t}\n\t" +(455:0-455:9) "\nfunction" --> (233:2-233:11) "\tfunction" +(455:9-455:24) " getContextName" --> (233:11-233:26) " getContextName" +(455:24-455:30) "(type)" --> (233:26-233:32) "(type)" +(455:30-456:2) " {\n " --> (233:32-234:0) " {" +(456:2-456:9) " return" --> (234:0-234:10) "\n\t\t\treturn" +(456:9-456:14) " type" --> (234:10-234:15) " type" +(456:14-456:29) ".displayName ||" --> (234:15-234:30) ".displayName ||" +(456:29-457:1) " 'Context';\n" --> (234:30-235:2) " \"Context\";\n\t" +(457:1-459:0) "}\n" --> (235:2-236:2) "\t}\n\t" +(459:0-459:9) "\nfunction" --> (236:2-236:11) "\tfunction" +(459:9-459:26) " getComponentName" --> (236:11-236:28) " getComponentName" +(459:26-459:32) "(type)" --> (236:28-236:34) "(type)" +(459:32-460:2) " {\n " --> (236:34-237:0) " {" +(460:2-460:6) " if " --> (237:0-237:7) "\n\t\t\tif " +(460:6-460:14) "(type ==" --> (237:7-237:15) "(type ==" +(460:14-460:20) " null)" --> (237:15-237:21) " null)" +(460:20-462:4) " {\n // Host root, text node or just invalid type.\n " --> (237:21-238:0) " {" +(462:4-462:11) " return" --> (238:0-238:11) "\n\t\t\t\treturn" +(462:11-463:3) " null;\n " --> (238:11-239:3) " null;\n\t\t" +(463:3-465:2) "}\n\n " --> (239:3-240:3) "\t}\n\t\t" +(465:2-466:4) " {\n " --> (240:3-241:0) "\t{" +(466:4-466:15) " if (typeof" --> (241:0-241:15) "\n\t\t\t\tif (typeof" +(466:15-466:20) " type" --> (241:15-241:20) " type" +(466:20-466:28) ".tag ===" --> (241:20-241:28) ".tag ===" +(466:28-466:38) " 'number')" --> (241:28-241:38) " \"number\")" +(466:38-467:6) " {\n " --> (241:38-242:0) " {" +(467:6-467:12) " error" --> (242:0-242:11) "\n\t\t\t\t\terror" +(467:12-467:70) "('Received an unexpected object in getComponentName(). ' +" --> (242:11-242:69) "(\"Received an unexpected object in getComponentName(). \" +" +(467:70-467:125) " 'This is likely a bug in React. Please file an issue.'" --> (242:69-242:124) " \"This is likely a bug in React. Please file an issue.\"" +(467:125-468:5) ");\n " --> (242:124-243:4) ");\n\t\t\t" +(468:5-469:3) "}\n " --> (243:4-244:3) "\t}\n\t\t" +(469:3-471:2) "}\n\n " --> (244:3-245:0) "\t}" +(471:2-471:13) " if (typeof" --> (245:0-245:14) "\n\t\t\tif (typeof" +(471:13-471:22) " type ===" --> (245:14-245:23) " type ===" +(471:22-471:34) " 'function')" --> (245:23-245:35) " \"function\")" +(471:34-472:4) " {\n " --> (245:35-246:0) " {" +(472:4-472:11) " return" --> (246:0-246:11) "\n\t\t\t\treturn" +(472:11-472:16) " type" --> (246:11-246:16) " type" +(472:16-472:31) ".displayName ||" --> (246:16-246:31) ".displayName ||" +(472:31-472:36) " type" --> (246:31-246:36) " type" +(472:36-472:44) ".name ||" --> (246:36-246:44) ".name ||" +(472:44-473:3) " null;\n " --> (246:44-247:3) " null;\n\t\t" +(473:3-475:2) "}\n\n " --> (247:3-248:0) "\t}" +(475:2-475:13) " if (typeof" --> (248:0-248:14) "\n\t\t\tif (typeof" +(475:13-475:22) " type ===" --> (248:14-248:23) " type ===" +(475:22-475:32) " 'string')" --> (248:23-248:33) " \"string\")" +(475:32-476:4) " {\n " --> (248:33-249:0) " {" +(476:4-476:11) " return" --> (249:0-249:11) "\n\t\t\t\treturn" +(476:11-477:3) " type;\n " --> (249:11-250:3) " type;\n\t\t" +(477:3-479:2) "}\n\n " --> (250:3-251:0) "\t}" +(479:2-479:10) " switch " --> (251:0-251:11) "\n\t\t\tswitch " +(479:10-479:2) " switch " --> (251:11-251:17) "(type)" +(479:2-480:4) " switch (type) {\n " --> (251:17-252:0) " {" +(480:4-480:9) " case" --> (252:0-252:9) "\n\t\t\t\tcase" +(480:9-480:17) " exports" --> (252:9-252:17) " exports" +(480:17-481:6) ".Fragment:\n " --> (252:17-253:0) ".Fragment:" +(481:6-481:13) " return" --> (253:0-253:12) "\n\t\t\t\t\treturn" +(481:13-483:4) " 'Fragment';\n\n " --> (253:12-254:0) " \"Fragment\";" +(483:4-483:9) " case" --> (254:0-254:9) "\n\t\t\t\tcase" +(483:9-484:6) " REACT_PORTAL_TYPE:\n " --> (254:9-255:0) " REACT_PORTAL_TYPE:" +(484:6-484:13) " return" --> (255:0-255:12) "\n\t\t\t\t\treturn" +(484:13-486:4) " 'Portal';\n\n " --> (255:12-256:0) " \"Portal\";" +(486:4-486:9) " case" --> (256:0-256:9) "\n\t\t\t\tcase" +(486:9-486:17) " exports" --> (256:9-256:17) " exports" +(486:17-487:6) ".Profiler:\n " --> (256:17-257:0) ".Profiler:" +(487:6-487:13) " return" --> (257:0-257:12) "\n\t\t\t\t\treturn" +(487:13-489:4) " 'Profiler';\n\n " --> (257:12-258:0) " \"Profiler\";" +(489:4-489:9) " case" --> (258:0-258:9) "\n\t\t\t\tcase" +(489:9-489:17) " exports" --> (258:9-258:17) " exports" +(489:17-490:6) ".StrictMode:\n " --> (258:17-259:0) ".StrictMode:" +(490:6-490:13) " return" --> (259:0-259:12) "\n\t\t\t\t\treturn" +(490:13-492:4) " 'StrictMode';\n\n " --> (259:12-260:0) " \"StrictMode\";" +(492:4-492:9) " case" --> (260:0-260:9) "\n\t\t\t\tcase" +(492:9-492:17) " exports" --> (260:9-260:17) " exports" +(492:17-493:6) ".Suspense:\n " --> (260:17-261:0) ".Suspense:" +(493:6-493:13) " return" --> (261:0-261:12) "\n\t\t\t\t\treturn" +(493:13-495:4) " 'Suspense';\n\n " --> (261:12-262:0) " \"Suspense\";" +(495:4-495:9) " case" --> (262:0-262:9) "\n\t\t\t\tcase" +(495:9-496:6) " REACT_SUSPENSE_LIST_TYPE:\n " --> (262:9-263:0) " REACT_SUSPENSE_LIST_TYPE:" +(496:6-496:13) " return" --> (263:0-263:12) "\n\t\t\t\t\treturn" +(496:13-497:3) " 'SuspenseList';\n " --> (263:12-264:3) " \"SuspenseList\";\n\t\t" +(497:3-499:2) "}\n\n " --> (264:3-265:0) "\t}" +(499:2-499:13) " if (typeof" --> (265:0-265:14) "\n\t\t\tif (typeof" +(499:13-499:22) " type ===" --> (265:14-265:23) " type ===" +(499:22-499:32) " 'object')" --> (265:23-265:33) " \"object\")" +(499:32-500:4) " {\n " --> (265:33-266:0) " {" +(500:4-500:12) " switch " --> (266:0-266:12) "\n\t\t\t\tswitch " +(500:12-500:17) "(type" --> (266:12-266:17) "(type" +(500:17-500:4) " switch (type" --> (266:17-266:27) ".$$typeof)" +(500:4-501:6) " switch (type.$$typeof) {\n " --> (266:27-267:0) " {" +(501:6-501:11) " case" --> (267:0-267:10) "\n\t\t\t\t\tcase" +(501:11-502:8) " REACT_CONTEXT_TYPE:\n " --> (267:10-268:6) " REACT_CONTEXT_TYPE:\n\t\t\t\t\t" +(502:8-502:12) " var" --> (268:6-268:10) "\tvar" +(502:12-502:22) " context =" --> (268:10-268:20) " context =" +(502:22-503:8) " type;\n " --> (268:20-269:0) " type;" +(503:8-503:15) " return" --> (269:0-269:13) "\n\t\t\t\t\t\treturn" +(503:15-503:30) " getContextName" --> (269:13-269:28) " getContextName" +(503:30-503:38) "(context" --> (269:28-269:36) "(context" +(503:38-503:41) ") +" --> (269:36-269:39) ") +" +(503:41-505:6) " '.Consumer';\n\n " --> (269:39-270:0) " \".Consumer\";" +(505:6-505:11) " case" --> (270:0-270:10) "\n\t\t\t\t\tcase" +(505:11-506:8) " REACT_PROVIDER_TYPE:\n " --> (270:10-271:6) " REACT_PROVIDER_TYPE:\n\t\t\t\t\t" +(506:8-506:12) " var" --> (271:6-271:10) "\tvar" +(506:12-506:23) " provider =" --> (271:10-271:21) " provider =" +(506:23-507:8) " type;\n " --> (271:21-272:0) " type;" +(507:8-507:15) " return" --> (272:0-272:13) "\n\t\t\t\t\t\treturn" +(507:15-507:30) " getContextName" --> (272:13-272:28) " getContextName" +(507:30-507:39) "(provider" --> (272:28-272:37) "(provider" +(507:39-507:48) "._context" --> (272:37-272:46) "._context" +(507:48-507:51) ") +" --> (272:46-272:49) ") +" +(507:51-509:6) " '.Provider';\n\n " --> (272:49-273:0) " \".Provider\";" +(509:6-509:11) " case" --> (273:0-273:10) "\n\t\t\t\t\tcase" +(509:11-510:8) " REACT_FORWARD_REF_TYPE:\n " --> (273:10-274:0) " REACT_FORWARD_REF_TYPE:" +(510:8-510:15) " return" --> (274:0-274:13) "\n\t\t\t\t\t\treturn" +(510:15-510:30) " getWrappedName" --> (274:13-274:28) " getWrappedName" +(510:30-510:36) "(type," --> (274:28-274:34) "(type," +(510:36-510:41) " type" --> (274:34-274:39) " type" +(510:41-510:49) ".render," --> (274:39-274:47) ".render," +(510:49-510:62) " 'ForwardRef'" --> (274:47-274:60) " \"ForwardRef\"" +(510:62-512:6) ");\n\n " --> (274:60-275:0) ");" +(512:6-512:11) " case" --> (275:0-275:10) "\n\t\t\t\t\tcase" +(512:11-513:8) " REACT_MEMO_TYPE:\n " --> (275:10-276:0) " REACT_MEMO_TYPE:" +(513:8-513:15) " return" --> (276:0-276:13) "\n\t\t\t\t\t\treturn" +(513:15-513:32) " getComponentName" --> (276:13-276:30) " getComponentName" +(513:32-513:37) "(type" --> (276:30-276:35) "(type" +(513:37-513:42) ".type" --> (276:35-276:40) ".type" +(513:42-515:6) ");\n\n " --> (276:40-277:0) ");" +(515:6-515:11) " case" --> (277:0-277:10) "\n\t\t\t\t\tcase" +(515:11-516:8) " REACT_BLOCK_TYPE:\n " --> (277:10-278:0) " REACT_BLOCK_TYPE:" +(516:8-516:15) " return" --> (278:0-278:13) "\n\t\t\t\t\t\treturn" +(516:15-516:32) " getComponentName" --> (278:13-278:30) " getComponentName" +(516:32-516:37) "(type" --> (278:30-278:35) "(type" +(516:37-516:45) "._render" --> (278:35-278:43) "._render" +(516:45-518:6) ");\n\n " --> (278:43-279:0) ");" +(518:6-518:11) " case" --> (279:0-279:10) "\n\t\t\t\t\tcase" +(518:11-519:8) " REACT_LAZY_TYPE:\n " --> (279:10-280:6) " REACT_LAZY_TYPE:\n\t\t\t\t\t" +(519:8-520:10) " {\n " --> (280:6-281:7) "\t{\n\t\t\t\t\t\t" +(520:10-520:14) " var" --> (281:7-281:11) "\tvar" +(520:14-520:30) " lazyComponent =" --> (281:11-281:27) " lazyComponent =" +(520:30-521:10) " type;\n " --> (281:27-282:7) " type;\n\t\t\t\t\t\t" +(521:10-521:14) " var" --> (282:7-282:11) "\tvar" +(521:14-521:24) " payload =" --> (282:11-282:21) " payload =" +(521:24-521:38) " lazyComponent" --> (282:21-282:35) " lazyComponent" +(521:38-522:10) "._payload;\n " --> (282:35-283:7) "._payload;\n\t\t\t\t\t\t" +(522:10-522:14) " var" --> (283:7-283:11) "\tvar" +(522:14-522:21) " init =" --> (283:11-283:18) " init =" +(522:21-522:35) " lazyComponent" --> (283:18-283:32) " lazyComponent" +(522:35-524:10) "._init;\n\n " --> (283:32-284:0) "._init;" +(524:10-524:14) " try" --> (284:0-284:11) "\n\t\t\t\t\t\t\ttry" +(524:14-525:12) " {\n " --> (284:11-285:0) " {" +(525:12-525:19) " return" --> (285:0-285:15) "\n\t\t\t\t\t\t\t\treturn" +(525:19-525:36) " getComponentName" --> (285:15-285:32) " getComponentName" +(525:36-525:41) "(init" --> (285:32-285:37) "(init" +(525:41-525:49) "(payload" --> (285:37-285:45) "(payload" +(525:49-525:50) ")" --> (285:45-285:46) ")" +(525:50-526:11) ");\n " --> (285:46-286:7) ");\n\t\t\t\t\t\t" +(526:11-526:19) "} catch " --> (286:7-286:16) "\t} catch " +(526:19-526:22) "(x)" --> (286:16-286:19) "(x)" +(526:22-527:12) " {\n " --> (286:19-287:0) " {" +(527:12-527:19) " return" --> (287:0-287:15) "\n\t\t\t\t\t\t\t\treturn" +(527:19-528:11) " null;\n " --> (287:15-288:7) " null;\n\t\t\t\t\t\t" +(528:11-529:9) "}\n " --> (288:7-289:6) "\t}\n\t\t\t\t\t" +(529:9-530:5) "}\n " --> (289:6-290:4) "\t}\n\t\t\t" +(530:5-531:3) "}\n " --> (290:4-291:3) "\t}\n\t\t" +(531:3-533:2) "}\n\n " --> (291:3-292:0) "\t}" +(533:2-533:9) " return" --> (292:0-292:10) "\n\t\t\treturn" +(533:9-534:1) " null;\n" --> (292:10-293:2) " null;\n\t" +(534:1-536:0) "}\n" --> (293:2-294:2) "\t}\n\t" +(536:0-536:4) "\nvar" --> (294:2-294:6) "\tvar" +(536:4-536:21) " hasOwnProperty =" --> (294:6-294:23) " hasOwnProperty =" +(536:21-536:28) " Object" --> (294:23-294:30) " Object" +(536:28-536:38) ".prototype" --> (294:30-294:40) ".prototype" +(536:38-537:0) ".hasOwnProperty;" --> (294:40-295:2) ".hasOwnProperty;\n\t" +(537:0-537:4) "\nvar" --> (295:2-295:6) "\tvar" +(537:4-537:21) " RESERVED_PROPS =" --> (295:6-295:23) " RESERVED_PROPS =" +(537:21-538:2) " {\n " --> (295:23-296:3) " {\n\t\t" +(538:2-538:7) " key:" --> (296:3-296:8) "\tkey:" +(538:7-539:2) " true,\n " --> (296:8-297:3) " true,\n\t\t" +(539:2-539:7) " ref:" --> (297:3-297:8) "\tref:" +(539:7-540:2) " true,\n " --> (297:8-298:3) " true,\n\t\t" +(540:2-540:10) " __self:" --> (298:3-298:11) "\t__self:" +(540:10-541:2) " true,\n " --> (298:11-299:3) " true,\n\t\t" +(541:2-541:12) " __source:" --> (299:3-299:13) "\t__source:" +(541:12-542:1) " true\n" --> (299:13-300:2) " true\n\t" +(542:1-543:0) "};" --> (300:2-301:2) "\t};\n\t" +(543:0-543:4) "\nvar" --> (301:2-301:6) "\tvar" +(543:4-543:32) " specialPropKeyWarningShown," --> (301:6-301:34) " specialPropKeyWarningShown," +(543:32-543:60) " specialPropRefWarningShown," --> (301:34-301:62) " specialPropRefWarningShown," +(543:60-545:0) " didWarnAboutStringRefs;\n" --> (301:62-302:2) " didWarnAboutStringRefs;\n\t" +(545:0-546:2) "\n{\n " --> (302:2-303:0) "\t{" +(546:2-546:27) " didWarnAboutStringRefs =" --> (303:0-303:28) "\n\t\t\tdidWarnAboutStringRefs =" +(546:27-546:29) " {" --> (303:28-303:29) " " +(546:29-547:1) "};\n" --> (303:29-304:2) "{};\n\t" +(547:1-549:0) "}\n" --> (304:2-305:2) "\t}\n\t" +(549:0-549:9) "\nfunction" --> (305:2-305:11) "\tfunction" +(549:9-549:21) " hasValidRef" --> (305:11-305:23) " hasValidRef" +(549:21-549:29) "(config)" --> (305:23-305:31) "(config)" +(549:29-550:2) " {\n " --> (305:31-306:3) " {\n\t\t" +(550:2-551:4) " {\n " --> (306:3-307:0) "\t{" +(551:4-551:8) " if " --> (307:0-307:8) "\n\t\t\t\tif " +(551:8-551:23) "(hasOwnProperty" --> (307:8-307:23) "(hasOwnProperty" +(551:23-551:28) ".call" --> (307:23-307:28) ".call" +(551:28-551:36) "(config," --> (307:28-307:36) "(config," +(551:36-551:42) " 'ref'" --> (307:36-307:42) " \"ref\"" +(551:42-551:44) "))" --> (307:42-307:44) "))" +(551:44-552:6) " {\n " --> (307:44-308:5) " {\n\t\t\t\t" +(552:6-552:10) " var" --> (308:5-308:9) "\tvar" +(552:10-552:19) " getter =" --> (308:9-308:18) " getter =" +(552:19-552:26) " Object" --> (308:18-308:25) " Object" +(552:26-552:51) ".getOwnPropertyDescriptor" --> (308:25-308:50) ".getOwnPropertyDescriptor" +(552:51-552:59) "(config," --> (308:50-308:58) "(config," +(552:59-552:65) " 'ref'" --> (308:58-308:64) " \"ref\"" +(552:65-552:66) ")" --> (308:64-308:65) ")" +(552:66-554:6) ".get;\n\n " --> (308:65-309:0) ".get;" +(554:6-554:10) " if " --> (309:0-309:9) "\n\t\t\t\t\tif " +(554:10-554:20) "(getter &&" --> (309:9-309:19) "(getter &&" +(554:20-554:27) " getter" --> (309:19-309:26) " getter" +(554:27-554:43) ".isReactWarning)" --> (309:26-309:42) ".isReactWarning)" +(554:43-555:8) " {\n " --> (309:42-310:0) " {" +(555:8-555:15) " return" --> (310:0-310:13) "\n\t\t\t\t\t\treturn" +(555:15-556:7) " false;\n " --> (310:13-311:5) " false;\n\t\t\t\t" +(556:7-557:5) "}\n " --> (311:5-312:4) "\t}\n\t\t\t" +(557:5-558:3) "}\n " --> (312:4-313:3) "\t}\n\t\t" +(558:3-560:2) "}\n\n " --> (313:3-314:0) "\t}" +(560:2-560:9) " return" --> (314:0-314:10) "\n\t\t\treturn" +(560:9-560:16) " config" --> (314:10-314:17) " config" +(560:16-560:24) ".ref !==" --> (314:17-314:25) ".ref !==" +(560:24-561:1) " undefined;\n" --> (314:25-315:2) " undefined;\n\t" +(561:1-563:0) "}\n" --> (315:2-316:2) "\t}\n\t" +(563:0-563:9) "\nfunction" --> (316:2-316:11) "\tfunction" +(563:9-563:21) " hasValidKey" --> (316:11-316:23) " hasValidKey" +(563:21-563:29) "(config)" --> (316:23-316:31) "(config)" +(563:29-564:2) " {\n " --> (316:31-317:3) " {\n\t\t" +(564:2-565:4) " {\n " --> (317:3-318:0) "\t{" +(565:4-565:8) " if " --> (318:0-318:8) "\n\t\t\t\tif " +(565:8-565:23) "(hasOwnProperty" --> (318:8-318:23) "(hasOwnProperty" +(565:23-565:28) ".call" --> (318:23-318:28) ".call" +(565:28-565:36) "(config," --> (318:28-318:36) "(config," +(565:36-565:42) " 'key'" --> (318:36-318:42) " \"key\"" +(565:42-565:44) "))" --> (318:42-318:44) "))" +(565:44-566:6) " {\n " --> (318:44-319:5) " {\n\t\t\t\t" +(566:6-566:10) " var" --> (319:5-319:9) "\tvar" +(566:10-566:19) " getter =" --> (319:9-319:18) " getter =" +(566:19-566:26) " Object" --> (319:18-319:25) " Object" +(566:26-566:51) ".getOwnPropertyDescriptor" --> (319:25-319:50) ".getOwnPropertyDescriptor" +(566:51-566:59) "(config," --> (319:50-319:58) "(config," +(566:59-566:65) " 'key'" --> (319:58-319:64) " \"key\"" +(566:65-566:66) ")" --> (319:64-319:65) ")" +(566:66-568:6) ".get;\n\n " --> (319:65-320:0) ".get;" +(568:6-568:10) " if " --> (320:0-320:9) "\n\t\t\t\t\tif " +(568:10-568:20) "(getter &&" --> (320:9-320:19) "(getter &&" +(568:20-568:27) " getter" --> (320:19-320:26) " getter" +(568:27-568:43) ".isReactWarning)" --> (320:26-320:42) ".isReactWarning)" +(568:43-569:8) " {\n " --> (320:42-321:0) " {" +(569:8-569:15) " return" --> (321:0-321:13) "\n\t\t\t\t\t\treturn" +(569:15-570:7) " false;\n " --> (321:13-322:5) " false;\n\t\t\t\t" +(570:7-571:5) "}\n " --> (322:5-323:4) "\t}\n\t\t\t" +(571:5-572:3) "}\n " --> (323:4-324:3) "\t}\n\t\t" +(572:3-574:2) "}\n\n " --> (324:3-325:0) "\t}" +(574:2-574:9) " return" --> (325:0-325:10) "\n\t\t\treturn" +(574:9-574:16) " config" --> (325:10-325:17) " config" +(574:16-574:24) ".key !==" --> (325:17-325:25) ".key !==" +(574:24-575:1) " undefined;\n" --> (325:25-326:2) " undefined;\n\t" +(575:1-577:0) "}\n" --> (326:2-327:2) "\t}\n\t" +(577:0-577:9) "\nfunction" --> (327:2-327:11) "\tfunction" +(577:9-577:36) " defineKeyPropWarningGetter" --> (327:11-327:38) " defineKeyPropWarningGetter" +(577:36-577:43) "(props," --> (327:38-327:45) "(props," +(577:43-577:56) " displayName)" --> (327:45-327:58) " displayName)" +(577:56-578:2) " {\n " --> (327:58-328:3) " {\n\t\t" +(578:2-578:6) " var" --> (328:3-328:7) "\tvar" +(578:6-578:30) " warnAboutAccessingKey =" --> (328:7-328:31) " warnAboutAccessingKey =" +(578:30-578:42) " function ()" --> (328:31-328:42) " function()" +(578:42-579:4) " {\n " --> (328:42-329:4) " {\n\t\t\t" +(579:4-580:6) " {\n " --> (329:4-330:0) "\t{" +(580:6-580:11) " if (" --> (330:0-330:10) "\n\t\t\t\t\tif (" +(580:11-580:39) "!specialPropKeyWarningShown)" --> (330:10-330:38) "!specialPropKeyWarningShown)" +(580:39-581:8) " {\n " --> (330:38-331:0) " {" +(581:8-581:37) " specialPropKeyWarningShown =" --> (331:0-331:35) "\n\t\t\t\t\t\tspecialPropKeyWarningShown =" +(581:37-583:8) " true;\n\n " --> (331:35-332:0) " true;" +(583:8-583:14) " error" --> (332:0-332:12) "\n\t\t\t\t\t\terror" +(583:14-583:76) "('%s: `key` is not a prop. Trying to access it will result ' +" --> (332:12-332:74) "(\"%s: `key` is not a prop. Trying to access it will result \" +" +(583:76-583:143) " 'in `undefined` being returned. If you need to access the same ' +" --> (332:74-332:141) " \"in `undefined` being returned. If you need to access the same \" +" +(583:143-583:216) " 'value within the child component, you should pass it as a different ' +" --> (332:141-332:214) " \"value within the child component, you should pass it as a different \" +" +(583:216-583:266) " 'prop. (https://reactjs.org/link/special-props)'," --> (332:214-332:264) " \"prop. (https://reactjs.org/link/special-props)\"," +(583:266-583:278) " displayName" --> (332:264-332:276) " displayName" +(583:278-584:7) ");\n " --> (332:276-333:5) ");\n\t\t\t\t" +(584:7-585:5) "}\n " --> (333:5-334:4) "\t}\n\t\t\t" +(585:5-586:3) "}\n " --> (334:4-335:3) "\t}\n\t\t" +(586:3-588:2) "};\n\n " --> (335:3-336:0) "\t};" +(588:2-588:24) " warnAboutAccessingKey" --> (336:0-336:25) "\n\t\t\twarnAboutAccessingKey" +(588:24-588:41) ".isReactWarning =" --> (336:25-336:42) ".isReactWarning =" +(588:41-589:2) " true;\n " --> (336:42-337:0) " true;" +(589:2-589:9) " Object" --> (337:0-337:10) "\n\t\t\tObject" +(589:9-589:24) ".defineProperty" --> (337:10-337:25) ".defineProperty" +(589:24-589:31) "(props," --> (337:25-337:32) "(props," +(589:31-589:38) " 'key'," --> (337:32-337:39) " \"key\"," +(589:38-590:4) " {\n " --> (337:39-338:4) " {\n\t\t\t" +(590:4-590:9) " get:" --> (338:4-338:9) "\tget:" +(590:9-591:4) " warnAboutAccessingKey,\n " --> (338:9-339:4) " warnAboutAccessingKey,\n\t\t\t" +(591:4-591:18) " configurable:" --> (339:4-339:18) "\tconfigurable:" +(591:18-592:3) " true\n " --> (339:18-340:3) " true\n\t\t" +(592:3-592:4) "}" --> (340:3-340:5) "\t}" +(592:4-593:1) ");\n" --> (340:5-341:2) ");\n\t" +(593:1-595:0) "}\n" --> (341:2-342:2) "\t}\n\t" +(595:0-595:9) "\nfunction" --> (342:2-342:11) "\tfunction" +(595:9-595:36) " defineRefPropWarningGetter" --> (342:11-342:38) " defineRefPropWarningGetter" +(595:36-595:43) "(props," --> (342:38-342:45) "(props," +(595:43-595:56) " displayName)" --> (342:45-342:58) " displayName)" +(595:56-596:2) " {\n " --> (342:58-343:3) " {\n\t\t" +(596:2-596:6) " var" --> (343:3-343:7) "\tvar" +(596:6-596:30) " warnAboutAccessingRef =" --> (343:7-343:31) " warnAboutAccessingRef =" +(596:30-596:42) " function ()" --> (343:31-343:42) " function()" +(596:42-597:4) " {\n " --> (343:42-344:4) " {\n\t\t\t" +(597:4-598:6) " {\n " --> (344:4-345:0) "\t{" +(598:6-598:11) " if (" --> (345:0-345:10) "\n\t\t\t\t\tif (" +(598:11-598:39) "!specialPropRefWarningShown)" --> (345:10-345:38) "!specialPropRefWarningShown)" +(598:39-599:8) " {\n " --> (345:38-346:0) " {" +(599:8-599:37) " specialPropRefWarningShown =" --> (346:0-346:35) "\n\t\t\t\t\t\tspecialPropRefWarningShown =" +(599:37-601:8) " true;\n\n " --> (346:35-347:0) " true;" +(601:8-601:14) " error" --> (347:0-347:12) "\n\t\t\t\t\t\terror" +(601:14-601:76) "('%s: `ref` is not a prop. Trying to access it will result ' +" --> (347:12-347:74) "(\"%s: `ref` is not a prop. Trying to access it will result \" +" +(601:76-601:143) " 'in `undefined` being returned. If you need to access the same ' +" --> (347:74-347:141) " \"in `undefined` being returned. If you need to access the same \" +" +(601:143-601:216) " 'value within the child component, you should pass it as a different ' +" --> (347:141-347:214) " \"value within the child component, you should pass it as a different \" +" +(601:216-601:266) " 'prop. (https://reactjs.org/link/special-props)'," --> (347:214-347:264) " \"prop. (https://reactjs.org/link/special-props)\"," +(601:266-601:278) " displayName" --> (347:264-347:276) " displayName" +(601:278-602:7) ");\n " --> (347:276-348:5) ");\n\t\t\t\t" +(602:7-603:5) "}\n " --> (348:5-349:4) "\t}\n\t\t\t" +(603:5-604:3) "}\n " --> (349:4-350:3) "\t}\n\t\t" +(604:3-606:2) "};\n\n " --> (350:3-351:0) "\t};" +(606:2-606:24) " warnAboutAccessingRef" --> (351:0-351:25) "\n\t\t\twarnAboutAccessingRef" +(606:24-606:41) ".isReactWarning =" --> (351:25-351:42) ".isReactWarning =" +(606:41-607:2) " true;\n " --> (351:42-352:0) " true;" +(607:2-607:9) " Object" --> (352:0-352:10) "\n\t\t\tObject" +(607:9-607:24) ".defineProperty" --> (352:10-352:25) ".defineProperty" +(607:24-607:31) "(props," --> (352:25-352:32) "(props," +(607:31-607:38) " 'ref'," --> (352:32-352:39) " \"ref\"," +(607:38-608:4) " {\n " --> (352:39-353:4) " {\n\t\t\t" +(608:4-608:9) " get:" --> (353:4-353:9) "\tget:" +(608:9-609:4) " warnAboutAccessingRef,\n " --> (353:9-354:4) " warnAboutAccessingRef,\n\t\t\t" +(609:4-609:18) " configurable:" --> (354:4-354:18) "\tconfigurable:" +(609:18-610:3) " true\n " --> (354:18-355:3) " true\n\t\t" +(610:3-610:4) "}" --> (355:3-355:5) "\t}" +(610:4-611:1) ");\n" --> (355:5-356:2) ");\n\t" +(611:1-613:0) "}\n" --> (356:2-357:2) "\t}\n\t" +(613:0-613:9) "\nfunction" --> (357:2-357:11) "\tfunction" +(613:9-613:46) " warnIfStringRefCannotBeAutoConverted" --> (357:11-357:48) " warnIfStringRefCannotBeAutoConverted" +(613:46-613:54) "(config)" --> (357:48-357:56) "(config)" +(613:54-614:2) " {\n " --> (357:56-358:3) " {\n\t\t" +(614:2-615:4) " {\n " --> (358:3-359:0) "\t{" +(615:4-615:15) " if (typeof" --> (359:0-359:15) "\n\t\t\t\tif (typeof" +(615:15-615:22) " config" --> (359:15-359:22) " config" +(615:22-615:30) ".ref ===" --> (359:22-359:30) ".ref ===" +(615:30-615:42) " 'string' &&" --> (359:30-359:42) " \"string\" &&" +(615:42-615:60) " ReactCurrentOwner" --> (359:42-359:60) " ReactCurrentOwner" +(615:60-615:71) ".current &&" --> (359:60-359:71) ".current &&" +(615:71-615:78) " config" --> (359:71-359:78) " config" +(615:78-615:88) ".__self &&" --> (359:78-359:88) ".__self &&" +(615:88-615:106) " ReactCurrentOwner" --> (359:88-359:106) " ReactCurrentOwner" +(615:106-615:114) ".current" --> (359:106-359:114) ".current" +(615:114-615:128) ".stateNode !==" --> (359:114-359:128) ".stateNode !==" +(615:128-615:135) " config" --> (359:128-359:135) " config" +(615:135-615:143) ".__self)" --> (359:135-359:143) ".__self)" +(615:143-616:6) " {\n " --> (359:143-360:5) " {\n\t\t\t\t" +(616:6-616:10) " var" --> (360:5-360:9) "\tvar" +(616:10-616:26) " componentName =" --> (360:9-360:25) " componentName =" +(616:26-616:43) " getComponentName" --> (360:25-360:42) " getComponentName" +(616:43-616:61) "(ReactCurrentOwner" --> (360:42-360:60) "(ReactCurrentOwner" +(616:61-616:69) ".current" --> (360:60-360:68) ".current" +(616:69-616:74) ".type" --> (360:68-360:73) ".type" +(616:74-618:6) ");\n\n " --> (360:73-361:0) ");" +(618:6-618:11) " if (" --> (361:0-361:10) "\n\t\t\t\t\tif (" +(618:11-618:34) "!didWarnAboutStringRefs" --> (361:10-361:33) "!didWarnAboutStringRefs" +(618:34-618:50) "[componentName])" --> (361:33-361:49) "[componentName])" +(618:50-619:8) " {\n " --> (361:49-362:0) " {" +(619:8-619:14) " error" --> (362:0-362:12) "\n\t\t\t\t\t\terror" +(619:14-619:64) "('Component \"%s\" contains the string ref \"%s\". ' +" --> (362:12-362:66) "(\"Component \\\"%s\\\" contains the string ref \\\"%s\\\". \" +" +(619:64-619:136) " 'Support for string refs will be removed in a future major release. ' +" --> (362:66-362:138) " \"Support for string refs will be removed in a future major release. \" +" +(619:136-619:207) " 'This case cannot be automatically converted to an arrow function. ' +" --> (362:138-362:209) " \"This case cannot be automatically converted to an arrow function. \" +" +(619:207-619:291) " 'We ask you to manually fix this case by using useRef() or createRef() instead. ' +" --> (362:209-362:293) " \"We ask you to manually fix this case by using useRef() or createRef() instead. \" +" +(619:291-619:337) " 'Learn more about using refs safely here: ' +" --> (362:293-362:339) " \"Learn more about using refs safely here: \" +" +(619:337-619:388) " 'https://reactjs.org/link/strict-mode-string-ref'," --> (362:339-362:390) " \"https://reactjs.org/link/strict-mode-string-ref\"," +(619:388-619:403) " componentName," --> (362:390-362:405) " componentName," +(619:403-619:410) " config" --> (362:405-362:412) " config" +(619:410-619:414) ".ref" --> (362:412-362:416) ".ref" +(619:414-621:8) ");\n\n " --> (362:416-363:0) ");" +(621:8-621:31) " didWarnAboutStringRefs" --> (363:0-363:29) "\n\t\t\t\t\t\tdidWarnAboutStringRefs" +(621:31-621:48) "[componentName] =" --> (363:29-363:46) "[componentName] =" +(621:48-622:7) " true;\n " --> (363:46-364:5) " true;\n\t\t\t\t" +(622:7-623:5) "}\n " --> (364:5-365:4) "\t}\n\t\t\t" +(623:5-624:3) "}\n " --> (365:4-366:3) "\t}\n\t\t" +(624:3-625:1) "}\n" --> (366:3-367:2) "\t}\n\t" +(625:1-648:0) "}\n/**\n * Factory method to create a new React element. This no longer adheres to\n * the class pattern, so do not use new to call it. Also, instanceof check\n * will not work. Instead test $$typeof field against Symbol.for('react.element') to check\n * if something is a React Element.\n *\n * @param {*} type\n * @param {*} props\n * @param {*} key\n * @param {string|object} ref\n * @param {*} owner\n * @param {*} self A *temporary* helper to detect places where `this` is\n * different from the `owner` when React.createElement is called, so that we\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\n * functions, and as long as `this` and owner are the same, there will be no\n * change in behavior.\n * @param {*} source An annotation object (added by a transpiler or otherwise)\n * indicating filename, line number, and/or other information.\n * @internal\n */\n\n" --> (367:2-368:2) "\t}\n\t" +(648:0-648:4) "\nvar" --> (368:2-368:6) "\tvar" +(648:4-648:19) " ReactElement =" --> (368:6-368:21) " ReactElement =" +(648:19-648:29) " function " --> (368:21-368:30) " function" +(648:29-648:35) "(type," --> (368:30-368:36) "(type," +(648:35-648:40) " key," --> (368:36-368:41) " key," +(648:40-648:45) " ref," --> (368:41-368:46) " ref," +(648:45-648:51) " self," --> (368:46-368:52) " self," +(648:51-648:59) " source," --> (368:52-368:60) " source," +(648:59-648:66) " owner," --> (368:60-368:67) " owner," +(648:66-648:73) " props)" --> (368:67-368:74) " props)" +(648:73-649:2) " {\n " --> (368:74-369:3) " {\n\t\t" +(649:2-649:6) " var" --> (369:3-369:7) "\tvar" +(649:6-649:16) " element =" --> (369:7-369:17) " element =" +(649:16-651:4) " {\n // This tag allows us to uniquely identify this as a React Element\n " --> (369:17-370:4) " {\n\t\t\t" +(651:4-651:14) " $$typeof:" --> (370:4-370:14) "\t$$typeof:" +(651:14-653:10) " REACT_ELEMENT_TYPE,\n // Built-in properties that belong on the element\n type:" --> (370:14-371:4) " REACT_ELEMENT_TYPE,\n\t\t\t" +(653:10-654:9) " type,\n key:" --> (371:4-372:4) "\ttype,\n\t\t\t" +(654:9-655:9) " key,\n ref:" --> (372:4-373:4) "\tkey,\n\t\t\t" +(655:9-656:11) " ref,\n props:" --> (373:4-374:4) "\tref,\n\t\t\t" +(656:11-658:4) " props,\n // Record the component responsible for creating this element.\n " --> (374:4-375:4) "\tprops,\n\t\t\t" +(658:4-658:12) " _owner:" --> (375:4-375:12) "\t_owner:" +(658:12-659:3) " owner\n " --> (375:12-376:3) " owner\n\t\t" +(659:3-661:2) "};\n\n " --> (376:3-377:3) "\t};\n\t\t" +(661:2-666:4) " {\n // The validation flag is currently mutative. We put it on\n // an external backing store so that we can freeze the whole object.\n // This can be replaced with a WeakMap once they are implemented in\n // commonly used development environments.\n " --> (377:3-378:0) "\t{" +(666:4-666:12) " element" --> (378:0-378:12) "\n\t\t\t\telement" +(666:12-666:21) "._store =" --> (378:12-378:21) "._store =" +(666:21-666:23) " {" --> (378:21-378:22) " " +(666:23-671:4) "}; // To make comparing ReactElements easier for testing purposes, we make\n // the validation flag non-enumerable (where possible, which should\n // include every environment we run tests in), so the test framework\n // ignores it.\n\n " --> (378:22-379:0) "{};" +(671:4-671:11) " Object" --> (379:0-379:11) "\n\t\t\t\tObject" +(671:11-671:26) ".defineProperty" --> (379:11-379:26) ".defineProperty" +(671:26-671:34) "(element" --> (379:26-379:34) "(element" +(671:34-671:42) "._store," --> (379:34-379:42) "._store," +(671:42-671:55) " 'validated'," --> (379:42-379:55) " \"validated\"," +(671:55-672:6) " {\n " --> (379:55-380:5) " {\n\t\t\t\t" +(672:6-672:20) " configurable:" --> (380:5-380:19) "\tconfigurable:" +(672:20-673:6) " false,\n " --> (380:19-381:5) " false,\n\t\t\t\t" +(673:6-673:18) " enumerable:" --> (381:5-381:17) "\tenumerable:" +(673:18-674:6) " false,\n " --> (381:17-382:5) " false,\n\t\t\t\t" +(674:6-674:16) " writable:" --> (382:5-382:15) "\twritable:" +(674:16-675:6) " true,\n " --> (382:15-383:5) " true,\n\t\t\t\t" +(675:6-675:13) " value:" --> (383:5-383:12) "\tvalue:" +(675:13-676:5) " false\n " --> (383:12-384:4) " false\n\t\t\t" +(676:5-676:6) "}" --> (384:4-384:6) "\t}" +(676:6-678:4) "); // self and source are DEV only properties.\n\n " --> (384:6-385:0) ");" +(678:4-678:11) " Object" --> (385:0-385:11) "\n\t\t\t\tObject" +(678:11-678:26) ".defineProperty" --> (385:11-385:26) ".defineProperty" +(678:26-678:35) "(element," --> (385:26-385:35) "(element," +(678:35-678:44) " '_self'," --> (385:35-385:44) " \"_self\"," +(678:44-679:6) " {\n " --> (385:44-386:5) " {\n\t\t\t\t" +(679:6-679:20) " configurable:" --> (386:5-386:19) "\tconfigurable:" +(679:20-680:6) " false,\n " --> (386:19-387:5) " false,\n\t\t\t\t" +(680:6-680:18) " enumerable:" --> (387:5-387:17) "\tenumerable:" +(680:18-681:6) " false,\n " --> (387:17-388:5) " false,\n\t\t\t\t" +(681:6-681:16) " writable:" --> (388:5-388:15) "\twritable:" +(681:16-682:6) " false,\n " --> (388:15-389:5) " false,\n\t\t\t\t" +(682:6-682:13) " value:" --> (389:5-389:12) "\tvalue:" +(682:13-683:5) " self\n " --> (389:12-390:4) " self\n\t\t\t" +(683:5-683:6) "}" --> (390:4-390:6) "\t}" +(683:6-686:4) "); // Two elements created in two different places should be considered\n // equal for testing purposes and therefore we hide it from enumeration.\n\n " --> (390:6-391:0) ");" +(686:4-686:11) " Object" --> (391:0-391:11) "\n\t\t\t\tObject" +(686:11-686:26) ".defineProperty" --> (391:11-391:26) ".defineProperty" +(686:26-686:35) "(element," --> (391:26-391:35) "(element," +(686:35-686:46) " '_source'," --> (391:35-391:46) " \"_source\"," +(686:46-687:6) " {\n " --> (391:46-392:5) " {\n\t\t\t\t" +(687:6-687:20) " configurable:" --> (392:5-392:19) "\tconfigurable:" +(687:20-688:6) " false,\n " --> (392:19-393:5) " false,\n\t\t\t\t" +(688:6-688:18) " enumerable:" --> (393:5-393:17) "\tenumerable:" +(688:18-689:6) " false,\n " --> (393:17-394:5) " false,\n\t\t\t\t" +(689:6-689:16) " writable:" --> (394:5-394:15) "\twritable:" +(689:16-690:6) " false,\n " --> (394:15-395:5) " false,\n\t\t\t\t" +(690:6-690:13) " value:" --> (395:5-395:12) "\tvalue:" +(690:13-691:5) " source\n " --> (395:12-396:4) " source\n\t\t\t" +(691:5-691:6) "}" --> (396:4-396:6) "\t}" +(691:6-693:4) ");\n\n " --> (396:6-397:0) ");" +(693:4-693:8) " if " --> (397:0-397:8) "\n\t\t\t\tif " +(693:8-693:15) "(Object" --> (397:8-397:15) "(Object" +(693:15-693:23) ".freeze)" --> (397:15-397:23) ".freeze)" +(693:23-694:6) " {\n " --> (397:23-398:0) " {" +(694:6-694:13) " Object" --> (398:0-398:12) "\n\t\t\t\t\tObject" +(694:13-694:20) ".freeze" --> (398:12-398:19) ".freeze" +(694:20-694:28) "(element" --> (398:19-398:27) "(element" +(694:28-694:34) ".props" --> (398:27-398:33) ".props" +(694:34-695:6) ");\n " --> (398:33-399:0) ");" +(695:6-695:13) " Object" --> (399:0-399:12) "\n\t\t\t\t\tObject" +(695:13-695:20) ".freeze" --> (399:12-399:19) ".freeze" +(695:20-695:28) "(element" --> (399:19-399:27) "(element" +(695:28-696:5) ");\n " --> (399:27-400:4) ");\n\t\t\t" +(696:5-697:3) "}\n " --> (400:4-401:3) "\t}\n\t\t" +(697:3-699:2) "}\n\n " --> (401:3-402:0) "\t}" +(699:2-699:9) " return" --> (402:0-402:10) "\n\t\t\treturn" +(699:9-700:1) " element;\n" --> (402:10-403:2) " element;\n\t" +(700:1-706:0) "};\n/**\n * Create and return a new ReactElement of the given type.\n * See https://reactjs.org/docs/react-api.html#createelement\n */\n" --> (403:2-404:2) "\t};\n\t" +(706:0-706:9) "\nfunction" --> (404:2-404:11) "\tfunction" +(706:9-706:23) " createElement" --> (404:11-404:25) " createElement" +(706:23-706:29) "(type," --> (404:25-404:31) "(type," +(706:29-706:37) " config," --> (404:31-404:39) " config," +(706:37-706:47) " children)" --> (404:39-404:49) " children)" +(706:47-707:2) " {\n " --> (404:49-405:3) " {\n\t\t" +(707:2-707:6) " var" --> (405:3-405:7) "\tvar" +(707:6-709:2) " propName; // Reserved names are extracted\n\n " --> (405:7-406:3) " propName;\n\t\t" +(709:2-709:6) " var" --> (406:3-406:7) "\tvar" +(709:6-709:14) " props =" --> (406:7-406:15) " props =" +(709:14-709:16) " {" --> (406:15-406:16) " " +(709:16-710:2) "};\n " --> (406:16-407:3) "{};\n\t\t" +(710:2-710:6) " var" --> (407:3-407:7) "\tvar" +(710:6-710:12) " key =" --> (407:7-407:13) " key =" +(710:12-711:2) " null;\n " --> (407:13-408:3) " null;\n\t\t" +(711:2-711:6) " var" --> (408:3-408:7) "\tvar" +(711:6-711:12) " ref =" --> (408:7-408:13) " ref =" +(711:12-712:2) " null;\n " --> (408:13-409:3) " null;\n\t\t" +(712:2-712:6) " var" --> (409:3-409:7) "\tvar" +(712:6-712:13) " self =" --> (409:7-409:14) " self =" +(712:13-713:2) " null;\n " --> (409:14-410:3) " null;\n\t\t" +(713:2-713:6) " var" --> (410:3-410:7) "\tvar" +(713:6-713:15) " source =" --> (410:7-410:16) " source =" +(713:15-715:2) " null;\n\n " --> (410:16-411:0) " null;" +(715:2-715:6) " if " --> (411:0-411:7) "\n\t\t\tif " +(715:6-715:16) "(config !=" --> (411:7-411:17) "(config !=" +(715:16-715:22) " null)" --> (411:17-411:23) " null)" +(715:22-716:4) " {\n " --> (411:23-412:0) " {" +(716:4-716:8) " if " --> (412:0-412:8) "\n\t\t\t\tif " +(716:8-716:20) "(hasValidRef" --> (412:8-412:20) "(hasValidRef" +(716:20-716:27) "(config" --> (412:20-412:27) "(config" +(716:27-716:29) "))" --> (412:27-412:29) "))" +(716:29-717:6) " {\n " --> (412:29-413:0) " {" +(717:6-717:12) " ref =" --> (413:0-413:11) "\n\t\t\t\t\tref =" +(717:12-717:19) " config" --> (413:11-413:18) " config" +(717:19-719:6) ".ref;\n\n " --> (413:18-414:5) ".ref;\n\t\t\t\t" +(719:6-720:8) " {\n " --> (414:5-415:0) "\t{" +(720:8-720:45) " warnIfStringRefCannotBeAutoConverted" --> (415:0-415:43) "\n\t\t\t\t\t\twarnIfStringRefCannotBeAutoConverted" +(720:45-720:52) "(config" --> (415:43-415:50) "(config" +(720:52-721:7) ");\n " --> (415:50-416:5) ");\n\t\t\t\t" +(721:7-722:5) "}\n " --> (416:5-417:4) "\t}\n\t\t\t" +(722:5-724:4) "}\n\n " --> (417:4-418:0) "\t}" +(724:4-724:8) " if " --> (418:0-418:8) "\n\t\t\t\tif " +(724:8-724:20) "(hasValidKey" --> (418:8-418:20) "(hasValidKey" +(724:20-724:27) "(config" --> (418:20-418:27) "(config" +(724:27-724:29) "))" --> (418:27-418:29) "))" +(724:29-725:6) " {\n " --> (418:29-419:0) " {" +(725:6-725:12) " key =" --> (419:0-419:11) "\n\t\t\t\t\tkey =" +(725:12-725:17) " '' +" --> (419:11-419:16) " \"\" +" +(725:17-725:24) " config" --> (419:16-419:23) " config" +(725:24-726:5) ".key;\n " --> (419:23-420:4) ".key;\n\t\t\t" +(726:5-728:4) "}\n\n " --> (420:4-421:0) "\t}" +(728:4-728:11) " self =" --> (421:0-421:11) "\n\t\t\t\tself =" +(728:11-728:18) " config" --> (421:11-421:18) " config" +(728:18-728:29) ".__self ===" --> (421:18-421:29) ".__self ===" +(728:29-728:41) " undefined ?" --> (421:29-421:41) " undefined ?" +(728:41-728:48) " null :" --> (421:41-421:48) " null :" +(728:48-728:55) " config" --> (421:48-421:55) " config" +(728:55-729:4) ".__self;\n " --> (421:55-422:0) ".__self;" +(729:4-729:13) " source =" --> (422:0-422:13) "\n\t\t\t\tsource =" +(729:13-729:20) " config" --> (422:13-422:20) " config" +(729:20-729:33) ".__source ===" --> (422:20-422:33) ".__source ===" +(729:33-729:45) " undefined ?" --> (422:33-422:45) " undefined ?" +(729:45-729:52) " null :" --> (422:45-422:52) " null :" +(729:52-729:59) " config" --> (422:52-422:59) " config" +(729:59-731:4) ".__source; // Remaining properties are added to a new props object\n\n " --> (422:59-423:0) ".__source;" +(731:4-731:9) " for " --> (423:0-423:9) "\n\t\t\t\tfor " +(731:9-731:21) "(propName in" --> (423:9-423:21) "(propName in" +(731:21-731:29) " config)" --> (423:21-423:29) " config)" +(731:29-732:6) " {\n " --> (423:29-424:0) " {" +(732:6-732:10) " if " --> (424:0-424:9) "\n\t\t\t\t\tif " +(732:10-732:25) "(hasOwnProperty" --> (424:9-424:24) "(hasOwnProperty" +(732:25-732:30) ".call" --> (424:24-424:29) ".call" +(732:30-732:38) "(config," --> (424:29-424:37) "(config," +(732:38-732:47) " propName" --> (424:37-424:46) " propName" +(732:47-732:52) ") && " --> (424:46-424:51) ") && " +(732:52-732:67) "!RESERVED_PROPS" --> (424:51-424:66) "!RESERVED_PROPS" +(732:67-732:82) ".hasOwnProperty" --> (424:66-424:81) ".hasOwnProperty" +(732:82-732:91) "(propName" --> (424:81-424:90) "(propName" +(732:91-732:93) "))" --> (424:90-424:92) "))" +(732:93-733:8) " {\n " --> (424:92-425:0) " {" +(733:8-733:14) " props" --> (425:0-425:12) "\n\t\t\t\t\t\tprops" +(733:14-733:26) "[propName] =" --> (425:12-425:24) "[propName] =" +(733:26-733:33) " config" --> (425:24-425:31) " config" +(733:33-734:7) "[propName];\n " --> (425:31-426:5) "[propName];\n\t\t\t\t" +(734:7-735:5) "}\n " --> (426:5-427:4) "\t}\n\t\t\t" +(735:5-736:3) "}\n " --> (427:4-428:3) "\t}\n\t\t" +(736:3-740:2) "} // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n\n\n " --> (428:3-429:3) "\t}\n\t\t" +(740:2-740:6) " var" --> (429:3-429:7) "\tvar" +(740:6-740:23) " childrenLength =" --> (429:7-429:24) " childrenLength =" +(740:23-740:33) " arguments" --> (429:24-429:34) " arguments" +(740:33-740:42) ".length -" --> (429:34-429:43) ".length -" +(740:42-742:2) " 2;\n\n " --> (429:43-430:0) " 2;" +(742:2-742:6) " if " --> (430:0-430:7) "\n\t\t\tif " +(742:6-742:25) "(childrenLength ===" --> (430:7-430:26) "(childrenLength ===" +(742:25-742:28) " 1)" --> (430:26-430:29) " 1)" +(742:28-743:4) " {\n " --> (430:29-431:0) " {" +(743:4-743:10) " props" --> (431:0-431:10) "\n\t\t\t\tprops" +(743:10-743:21) ".children =" --> (431:10-431:21) ".children =" +(743:21-744:3) " children;\n " --> (431:21-432:3) " children;\n\t\t" +(744:3-744:13) "} else if " --> (432:3-432:14) "\t} else if " +(744:13-744:30) "(childrenLength >" --> (432:14-432:31) "(childrenLength >" +(744:30-744:33) " 1)" --> (432:31-432:34) " 1)" +(744:33-745:4) " {\n " --> (432:34-433:4) " {\n\t\t\t" +(745:4-745:8) " var" --> (433:4-433:8) "\tvar" +(745:8-745:21) " childArray =" --> (433:8-433:21) " childArray =" +(745:21-745:27) " Array" --> (433:21-433:27) " Array" +(745:27-745:42) "(childrenLength" --> (433:27-433:42) "(childrenLength" +(745:42-747:4) ");\n\n " --> (433:42-434:0) ");" +(747:4-747:9) " for " --> (434:0-434:9) "\n\t\t\t\tfor " +(747:9-747:13) "(var" --> (434:9-434:13) "(var" +(747:13-747:17) " i =" --> (434:13-434:17) " i =" +(747:17-747:20) " 0;" --> (434:17-434:20) " 0;" +(747:20-747:24) " i <" --> (434:20-434:24) " i <" +(747:24-747:40) " childrenLength;" --> (434:24-434:40) " childrenLength;" +(747:40-747:45) " i++)" --> (434:40-434:45) " i++)" +(747:45-748:6) " {\n " --> (434:45-435:0) " {" +(748:6-748:17) " childArray" --> (435:0-435:16) "\n\t\t\t\t\tchildArray" +(748:17-748:22) "[i] =" --> (435:16-435:21) "[i] =" +(748:22-748:32) " arguments" --> (435:21-435:31) " arguments" +(748:32-748:36) "[i +" --> (435:31-435:35) "[i +" +(748:36-749:5) " 2];\n " --> (435:35-436:4) " 2];\n\t\t\t" +(749:5-751:4) "}\n\n " --> (436:4-437:4) "\t}\n\t\t\t" +(751:4-752:6) " {\n " --> (437:4-438:0) "\t{" +(752:6-752:10) " if " --> (438:0-438:9) "\n\t\t\t\t\tif " +(752:10-752:17) "(Object" --> (438:9-438:16) "(Object" +(752:17-752:25) ".freeze)" --> (438:16-438:24) ".freeze)" +(752:25-753:8) " {\n " --> (438:24-439:0) " {" +(753:8-753:15) " Object" --> (439:0-439:13) "\n\t\t\t\t\t\tObject" +(753:15-753:22) ".freeze" --> (439:13-439:20) ".freeze" +(753:22-753:33) "(childArray" --> (439:20-439:31) "(childArray" +(753:33-754:7) ");\n " --> (439:31-440:5) ");\n\t\t\t\t" +(754:7-755:5) "}\n " --> (440:5-441:4) "\t}\n\t\t\t" +(755:5-757:4) "}\n\n " --> (441:4-442:0) "\t}" +(757:4-757:10) " props" --> (442:0-442:10) "\n\t\t\t\tprops" +(757:10-757:21) ".children =" --> (442:10-442:21) ".children =" +(757:21-758:3) " childArray;\n " --> (442:21-443:3) " childArray;\n\t\t" +(758:3-761:2) "} // Resolve default props\n\n\n " --> (443:3-444:0) "\t}" +(761:2-761:6) " if " --> (444:0-444:7) "\n\t\t\tif " +(761:6-761:14) "(type &&" --> (444:7-444:15) "(type &&" +(761:14-761:19) " type" --> (444:15-444:20) " type" +(761:19-761:33) ".defaultProps)" --> (444:20-444:34) ".defaultProps)" +(761:33-762:4) " {\n " --> (444:34-445:4) " {\n\t\t\t" +(762:4-762:8) " var" --> (445:4-445:8) "\tvar" +(762:8-762:23) " defaultProps =" --> (445:8-445:23) " defaultProps =" +(762:23-762:28) " type" --> (445:23-445:28) " type" +(762:28-764:4) ".defaultProps;\n\n " --> (445:28-446:0) ".defaultProps;" +(764:4-764:9) " for " --> (446:0-446:9) "\n\t\t\t\tfor " +(764:9-764:21) "(propName in" --> (446:9-446:21) "(propName in" +(764:21-764:35) " defaultProps)" --> (446:21-446:35) " defaultProps)" +(764:35-765:6) " {\n " --> (446:35-447:0) " {" +(765:6-765:10) " if " --> (447:0-447:9) "\n\t\t\t\t\tif " +(765:10-765:16) "(props" --> (447:9-447:15) "(props" +(765:16-765:30) "[propName] ===" --> (447:15-447:29) "[propName] ===" +(765:30-765:41) " undefined)" --> (447:29-447:40) " undefined)" +(765:41-766:8) " {\n " --> (447:40-448:0) " {" +(766:8-766:14) " props" --> (448:0-448:12) "\n\t\t\t\t\t\tprops" +(766:14-766:26) "[propName] =" --> (448:12-448:24) "[propName] =" +(766:26-766:39) " defaultProps" --> (448:24-448:37) " defaultProps" +(766:39-767:7) "[propName];\n " --> (448:37-449:5) "[propName];\n\t\t\t\t" +(767:7-768:5) "}\n " --> (449:5-450:4) "\t}\n\t\t\t" +(768:5-769:3) "}\n " --> (450:4-451:3) "\t}\n\t\t" +(769:3-771:2) "}\n\n " --> (451:3-452:3) "\t}\n\t\t" +(771:2-772:4) " {\n " --> (452:3-453:0) "\t{" +(772:4-772:8) " if " --> (453:0-453:8) "\n\t\t\t\tif " +(772:8-772:15) "(key ||" --> (453:8-453:15) "(key ||" +(772:15-772:20) " ref)" --> (453:15-453:20) " ref)" +(772:20-773:6) " {\n " --> (453:20-454:5) " {\n\t\t\t\t" +(773:6-773:10) " var" --> (454:5-454:9) "\tvar" +(773:10-773:31) " displayName = typeof" --> (454:9-454:30) " displayName = typeof" +(773:31-773:40) " type ===" --> (454:30-454:39) " type ===" +(773:40-773:53) " 'function' ?" --> (454:39-454:52) " \"function\" ?" +(773:53-773:58) " type" --> (454:52-454:57) " type" +(773:58-773:73) ".displayName ||" --> (454:57-454:72) ".displayName ||" +(773:73-773:78) " type" --> (454:72-454:77) " type" +(773:78-773:86) ".name ||" --> (454:77-454:85) ".name ||" +(773:86-773:98) " 'Unknown' :" --> (454:85-454:97) " \"Unknown\" :" +(773:98-775:6) " type;\n\n " --> (454:97-455:0) " type;" +(775:6-775:10) " if " --> (455:0-455:9) "\n\t\t\t\t\tif " +(775:10-775:15) "(key)" --> (455:9-455:14) "(key)" +(775:15-776:8) " {\n " --> (455:14-456:0) " {" +(776:8-776:35) " defineKeyPropWarningGetter" --> (456:0-456:33) "\n\t\t\t\t\t\tdefineKeyPropWarningGetter" +(776:35-776:42) "(props," --> (456:33-456:40) "(props," +(776:42-776:54) " displayName" --> (456:40-456:52) " displayName" +(776:54-777:7) ");\n " --> (456:52-457:5) ");\n\t\t\t\t" +(777:7-779:6) "}\n\n " --> (457:5-458:0) "\t}" +(779:6-779:10) " if " --> (458:0-458:9) "\n\t\t\t\t\tif " +(779:10-779:15) "(ref)" --> (458:9-458:14) "(ref)" +(779:15-780:8) " {\n " --> (458:14-459:0) " {" +(780:8-780:35) " defineRefPropWarningGetter" --> (459:0-459:33) "\n\t\t\t\t\t\tdefineRefPropWarningGetter" +(780:35-780:42) "(props," --> (459:33-459:40) "(props," +(780:42-780:54) " displayName" --> (459:40-459:52) " displayName" +(780:54-781:7) ");\n " --> (459:52-460:5) ");\n\t\t\t\t" +(781:7-782:5) "}\n " --> (460:5-461:4) "\t}\n\t\t\t" +(782:5-783:3) "}\n " --> (461:4-462:3) "\t}\n\t\t" +(783:3-785:2) "}\n\n " --> (462:3-463:0) "\t}" +(785:2-785:9) " return" --> (463:0-463:10) "\n\t\t\treturn" +(785:9-785:22) " ReactElement" --> (463:10-463:23) " ReactElement" +(785:22-785:28) "(type," --> (463:23-463:29) "(type," +(785:28-785:33) " key," --> (463:29-463:34) " key," +(785:33-785:38) " ref," --> (463:34-463:39) " ref," +(785:38-785:44) " self," --> (463:39-463:45) " self," +(785:44-785:52) " source," --> (463:45-463:53) " source," +(785:52-785:70) " ReactCurrentOwner" --> (463:53-463:71) " ReactCurrentOwner" +(785:70-785:79) ".current," --> (463:71-463:80) ".current," +(785:79-785:85) " props" --> (463:80-463:86) " props" +(785:85-786:1) ");\n" --> (463:86-464:2) ");\n\t" +(786:1-787:0) "}" --> (464:2-465:2) "\t}\n\t" +(787:0-787:9) "\nfunction" --> (465:2-465:11) "\tfunction" +(787:9-787:28) " cloneAndReplaceKey" --> (465:11-465:30) " cloneAndReplaceKey" +(787:28-787:40) "(oldElement," --> (465:30-465:42) "(oldElement," +(787:40-787:48) " newKey)" --> (465:42-465:50) " newKey)" +(787:48-788:2) " {\n " --> (465:50-466:3) " {\n\t\t" +(788:2-788:6) " var" --> (466:3-466:7) "\tvar" +(788:6-788:19) " newElement =" --> (466:7-466:20) " newElement =" +(788:19-788:32) " ReactElement" --> (466:20-466:33) " ReactElement" +(788:32-788:43) "(oldElement" --> (466:33-466:44) "(oldElement" +(788:43-788:49) ".type," --> (466:44-466:50) ".type," +(788:49-788:57) " newKey," --> (466:50-466:58) " newKey," +(788:57-788:68) " oldElement" --> (466:58-466:69) " oldElement" +(788:68-788:73) ".ref," --> (466:69-466:74) ".ref," +(788:73-788:84) " oldElement" --> (466:74-466:85) " oldElement" +(788:84-788:91) "._self," --> (466:85-466:92) "._self," +(788:91-788:102) " oldElement" --> (466:92-466:103) " oldElement" +(788:102-788:111) "._source," --> (466:103-466:112) "._source," +(788:111-788:122) " oldElement" --> (466:112-466:123) " oldElement" +(788:122-788:130) "._owner," --> (466:123-466:131) "._owner," +(788:130-788:141) " oldElement" --> (466:131-466:142) " oldElement" +(788:141-788:147) ".props" --> (466:142-466:148) ".props" +(788:147-789:2) ");\n " --> (466:148-467:0) ");" +(789:2-789:9) " return" --> (467:0-467:10) "\n\t\t\treturn" +(789:9-790:1) " newElement;\n" --> (467:10-468:2) " newElement;\n\t" +(790:1-796:0) "}\n/**\n * Clone and return a new ReactElement using element as the starting point.\n * See https://reactjs.org/docs/react-api.html#cloneelement\n */\n" --> (468:2-469:2) "\t}\n\t" +(796:0-796:9) "\nfunction" --> (469:2-469:11) "\tfunction" +(796:9-796:22) " cloneElement" --> (469:11-469:24) " cloneElement" +(796:22-796:31) "(element," --> (469:24-469:33) "(element," +(796:31-796:39) " config," --> (469:33-469:41) " config," +(796:39-796:49) " children)" --> (469:41-469:51) " children)" +(796:49-797:2) " {\n " --> (469:51-470:0) " {" +(797:2-797:9) " if (!!" --> (470:0-470:10) "\n\t\t\tif (!!" +(797:9-797:21) "(element ===" --> (470:10-470:22) "(element ===" +(797:21-797:29) " null ||" --> (470:22-470:30) " null ||" +(797:29-797:41) " element ===" --> (470:30-470:42) " element ===" +(797:41-797:53) " undefined))" --> (470:42-470:54) " undefined))" +(797:53-798:4) " {\n " --> (470:54-471:4) " {\n\t\t\t" +(798:4-799:6) " {\n " --> (471:4-472:0) "\t{" +(799:6-799:12) " throw" --> (472:0-472:11) "\n\t\t\t\t\tthrow" +(799:12-799:19) " Error(" --> (472:11-472:17) " Error" +(799:19-799:102) " \"React.cloneElement(...): The argument must be a React element, but you passed \" +" --> (472:17-472:100) "(\"React.cloneElement(...): The argument must be a React element, but you passed \" +" +(799:102-799:112) " element +" --> (472:100-472:110) " element +" +(799:112-799:117) " \".\" " --> (472:110-472:114) " \".\"" +(799:117-800:5) ");\n " --> (472:114-473:4) ");\n\t\t\t" +(800:5-801:3) "}\n " --> (473:4-474:3) "\t}\n\t\t" +(801:3-803:2) "}\n\n " --> (474:3-475:3) "\t}\n\t\t" +(803:2-803:6) " var" --> (475:3-475:7) "\tvar" +(803:6-805:2) " propName; // Original props are copied\n\n " --> (475:7-476:3) " propName;\n\t\t" +(805:2-805:6) " var" --> (476:3-476:7) "\tvar" +(805:6-805:14) " props =" --> (476:7-476:15) " props =" +(805:14-805:22) " _assign" --> (476:15-476:23) " _assign" +(805:22-805:24) "({" --> (476:23-476:24) "(" +(805:24-805:26) "}," --> (476:24-476:27) "{}," +(805:26-805:34) " element" --> (476:27-476:35) " element" +(805:34-805:40) ".props" --> (476:35-476:41) ".props" +(805:40-808:2) "); // Reserved names are extracted\n\n\n " --> (476:41-477:3) ");\n\t\t" +(808:2-808:6) " var" --> (477:3-477:7) "\tvar" +(808:6-808:12) " key =" --> (477:7-477:13) " key =" +(808:12-808:20) " element" --> (477:13-477:21) " element" +(808:20-809:2) ".key;\n " --> (477:21-478:3) ".key;\n\t\t" +(809:2-809:6) " var" --> (478:3-478:7) "\tvar" +(809:6-809:12) " ref =" --> (478:7-478:13) " ref =" +(809:12-809:20) " element" --> (478:13-478:21) " element" +(809:20-811:2) ".ref; // Self is preserved since the owner is preserved.\n\n " --> (478:21-479:3) ".ref;\n\t\t" +(811:2-811:6) " var" --> (479:3-479:7) "\tvar" +(811:6-811:13) " self =" --> (479:7-479:14) " self =" +(811:13-811:21) " element" --> (479:14-479:22) " element" +(811:21-815:2) "._self; // Source is preserved since cloneElement is unlikely to be targeted by a\n // transpiler, and the original source is probably a better indicator of the\n // true owner.\n\n " --> (479:22-480:3) "._self;\n\t\t" +(815:2-815:6) " var" --> (480:3-480:7) "\tvar" +(815:6-815:15) " source =" --> (480:7-480:16) " source =" +(815:15-815:23) " element" --> (480:16-480:24) " element" +(815:23-817:2) "._source; // Owner will be preserved, unless ref is overridden\n\n " --> (480:24-481:3) "._source;\n\t\t" +(817:2-817:6) " var" --> (481:3-481:7) "\tvar" +(817:6-817:14) " owner =" --> (481:7-481:15) " owner =" +(817:14-817:22) " element" --> (481:15-481:23) " element" +(817:22-819:2) "._owner;\n\n " --> (481:23-482:0) "._owner;" +(819:2-819:6) " if " --> (482:0-482:7) "\n\t\t\tif " +(819:6-819:16) "(config !=" --> (482:7-482:17) "(config !=" +(819:16-819:22) " null)" --> (482:17-482:23) " null)" +(819:22-820:4) " {\n " --> (482:23-483:0) " {" +(820:4-820:8) " if " --> (483:0-483:8) "\n\t\t\t\tif " +(820:8-820:20) "(hasValidRef" --> (483:8-483:20) "(hasValidRef" +(820:20-820:27) "(config" --> (483:20-483:27) "(config" +(820:27-820:29) "))" --> (483:27-483:29) "))" +(820:29-822:6) " {\n // Silently steal the ref from the parent.\n " --> (483:29-484:0) " {" +(822:6-822:12) " ref =" --> (484:0-484:11) "\n\t\t\t\t\tref =" +(822:12-822:19) " config" --> (484:11-484:18) " config" +(822:19-823:6) ".ref;\n " --> (484:18-485:0) ".ref;" +(823:6-823:14) " owner =" --> (485:0-485:13) "\n\t\t\t\t\towner =" +(823:14-823:32) " ReactCurrentOwner" --> (485:13-485:31) " ReactCurrentOwner" +(823:32-824:5) ".current;\n " --> (485:31-486:4) ".current;\n\t\t\t" +(824:5-826:4) "}\n\n " --> (486:4-487:0) "\t}" +(826:4-826:8) " if " --> (487:0-487:8) "\n\t\t\t\tif " +(826:8-826:20) "(hasValidKey" --> (487:8-487:20) "(hasValidKey" +(826:20-826:27) "(config" --> (487:20-487:27) "(config" +(826:27-826:29) "))" --> (487:27-487:29) "))" +(826:29-827:6) " {\n " --> (487:29-488:0) " {" +(827:6-827:12) " key =" --> (488:0-488:11) "\n\t\t\t\t\tkey =" +(827:12-827:17) " '' +" --> (488:11-488:16) " \"\" +" +(827:17-827:24) " config" --> (488:16-488:23) " config" +(827:24-828:5) ".key;\n " --> (488:23-489:4) ".key;\n\t\t\t" +(828:5-831:4) "} // Remaining properties override existing props\n\n\n " --> (489:4-490:4) "\t}\n\t\t\t" +(831:4-831:8) " var" --> (490:4-490:8) "\tvar" +(831:8-833:4) " defaultProps;\n\n " --> (490:8-491:0) " defaultProps;" +(833:4-833:8) " if " --> (491:0-491:8) "\n\t\t\t\tif " +(833:8-833:16) "(element" --> (491:8-491:16) "(element" +(833:16-833:24) ".type &&" --> (491:16-491:24) ".type &&" +(833:24-833:32) " element" --> (491:24-491:32) " element" +(833:32-833:37) ".type" --> (491:32-491:37) ".type" +(833:37-833:51) ".defaultProps)" --> (491:37-491:51) ".defaultProps)" +(833:51-834:6) " {\n " --> (491:51-492:0) " {" +(834:6-834:21) " defaultProps =" --> (492:0-492:20) "\n\t\t\t\t\tdefaultProps =" +(834:21-834:29) " element" --> (492:20-492:28) " element" +(834:29-834:34) ".type" --> (492:28-492:33) ".type" +(834:34-835:5) ".defaultProps;\n " --> (492:33-493:4) ".defaultProps;\n\t\t\t" +(835:5-837:4) "}\n\n " --> (493:4-494:0) "\t}" +(837:4-837:9) " for " --> (494:0-494:9) "\n\t\t\t\tfor " +(837:9-837:21) "(propName in" --> (494:9-494:21) "(propName in" +(837:21-837:29) " config)" --> (494:21-494:29) " config)" +(837:29-838:6) " {\n " --> (494:29-495:0) " {" +(838:6-838:10) " if " --> (495:0-495:9) "\n\t\t\t\t\tif " +(838:10-838:25) "(hasOwnProperty" --> (495:9-495:24) "(hasOwnProperty" +(838:25-838:30) ".call" --> (495:24-495:29) ".call" +(838:30-838:38) "(config," --> (495:29-495:37) "(config," +(838:38-838:47) " propName" --> (495:37-495:46) " propName" +(838:47-838:52) ") && " --> (495:46-495:51) ") && " +(838:52-838:67) "!RESERVED_PROPS" --> (495:51-495:66) "!RESERVED_PROPS" +(838:67-838:82) ".hasOwnProperty" --> (495:66-495:81) ".hasOwnProperty" +(838:82-838:91) "(propName" --> (495:81-495:90) "(propName" +(838:91-838:93) "))" --> (495:90-495:92) "))" +(838:93-839:8) " {\n " --> (495:92-496:0) " {" +(839:8-839:12) " if " --> (496:0-496:10) "\n\t\t\t\t\t\tif " +(839:12-839:19) "(config" --> (496:10-496:17) "(config" +(839:19-839:33) "[propName] ===" --> (496:17-496:31) "[propName] ===" +(839:33-839:46) " undefined &&" --> (496:31-496:44) " undefined &&" +(839:46-839:63) " defaultProps !==" --> (496:44-496:61) " defaultProps !==" +(839:63-839:74) " undefined)" --> (496:61-496:72) " undefined)" +(839:74-841:10) " {\n // Resolve default props\n " --> (496:72-497:0) " {" +(841:10-841:16) " props" --> (497:0-497:13) "\n\t\t\t\t\t\t\tprops" +(841:16-841:28) "[propName] =" --> (497:13-497:25) "[propName] =" +(841:28-841:41) " defaultProps" --> (497:25-497:38) " defaultProps" +(841:41-842:9) "[propName];\n " --> (497:38-498:6) "[propName];\n\t\t\t\t\t" +(842:9-842:15) "} else" --> (498:6-498:13) "\t} else" +(842:15-843:10) " {\n " --> (498:13-499:0) " {" +(843:10-843:16) " props" --> (499:0-499:13) "\n\t\t\t\t\t\t\tprops" +(843:16-843:28) "[propName] =" --> (499:13-499:25) "[propName] =" +(843:28-843:35) " config" --> (499:25-499:32) " config" +(843:35-844:9) "[propName];\n " --> (499:32-500:6) "[propName];\n\t\t\t\t\t" +(844:9-845:7) "}\n " --> (500:6-501:5) "\t}\n\t\t\t\t" +(845:7-846:5) "}\n " --> (501:5-502:4) "\t}\n\t\t\t" +(846:5-847:3) "}\n " --> (502:4-503:3) "\t}\n\t\t" +(847:3-851:2) "} // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n\n\n " --> (503:3-504:3) "\t}\n\t\t" +(851:2-851:6) " var" --> (504:3-504:7) "\tvar" +(851:6-851:23) " childrenLength =" --> (504:7-504:24) " childrenLength =" +(851:23-851:33) " arguments" --> (504:24-504:34) " arguments" +(851:33-851:42) ".length -" --> (504:34-504:43) ".length -" +(851:42-853:2) " 2;\n\n " --> (504:43-505:0) " 2;" +(853:2-853:6) " if " --> (505:0-505:7) "\n\t\t\tif " +(853:6-853:25) "(childrenLength ===" --> (505:7-505:26) "(childrenLength ===" +(853:25-853:28) " 1)" --> (505:26-505:29) " 1)" +(853:28-854:4) " {\n " --> (505:29-506:0) " {" +(854:4-854:10) " props" --> (506:0-506:10) "\n\t\t\t\tprops" +(854:10-854:21) ".children =" --> (506:10-506:21) ".children =" +(854:21-855:3) " children;\n " --> (506:21-507:3) " children;\n\t\t" +(855:3-855:13) "} else if " --> (507:3-507:14) "\t} else if " +(855:13-855:30) "(childrenLength >" --> (507:14-507:31) "(childrenLength >" +(855:30-855:33) " 1)" --> (507:31-507:34) " 1)" +(855:33-856:4) " {\n " --> (507:34-508:4) " {\n\t\t\t" +(856:4-856:8) " var" --> (508:4-508:8) "\tvar" +(856:8-856:21) " childArray =" --> (508:8-508:21) " childArray =" +(856:21-856:27) " Array" --> (508:21-508:27) " Array" +(856:27-856:42) "(childrenLength" --> (508:27-508:42) "(childrenLength" +(856:42-858:4) ");\n\n " --> (508:42-509:0) ");" +(858:4-858:9) " for " --> (509:0-509:9) "\n\t\t\t\tfor " +(858:9-858:13) "(var" --> (509:9-509:13) "(var" +(858:13-858:17) " i =" --> (509:13-509:17) " i =" +(858:17-858:20) " 0;" --> (509:17-509:20) " 0;" +(858:20-858:24) " i <" --> (509:20-509:24) " i <" +(858:24-858:40) " childrenLength;" --> (509:24-509:40) " childrenLength;" +(858:40-858:45) " i++)" --> (509:40-509:45) " i++)" +(858:45-859:6) " {\n " --> (509:45-510:0) " {" +(859:6-859:17) " childArray" --> (510:0-510:16) "\n\t\t\t\t\tchildArray" +(859:17-859:22) "[i] =" --> (510:16-510:21) "[i] =" +(859:22-859:32) " arguments" --> (510:21-510:31) " arguments" +(859:32-859:36) "[i +" --> (510:31-510:35) "[i +" +(859:36-860:5) " 2];\n " --> (510:35-511:4) " 2];\n\t\t\t" +(860:5-862:4) "}\n\n " --> (511:4-512:0) "\t}" +(862:4-862:10) " props" --> (512:0-512:10) "\n\t\t\t\tprops" +(862:10-862:21) ".children =" --> (512:10-512:21) ".children =" +(862:21-863:3) " childArray;\n " --> (512:21-513:3) " childArray;\n\t\t" +(863:3-865:2) "}\n\n " --> (513:3-514:0) "\t}" +(865:2-865:9) " return" --> (514:0-514:10) "\n\t\t\treturn" +(865:9-865:22) " ReactElement" --> (514:10-514:23) " ReactElement" +(865:22-865:30) "(element" --> (514:23-514:31) "(element" +(865:30-865:36) ".type," --> (514:31-514:37) ".type," +(865:36-865:41) " key," --> (514:37-514:42) " key," +(865:41-865:46) " ref," --> (514:42-514:47) " ref," +(865:46-865:52) " self," --> (514:47-514:53) " self," +(865:52-865:60) " source," --> (514:53-514:61) " source," +(865:60-865:67) " owner," --> (514:61-514:68) " owner," +(865:67-865:73) " props" --> (514:68-514:74) " props" +(865:73-866:1) ");\n" --> (514:74-515:2) ");\n\t" +(866:1-875:0) "}\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param {?object} object\n * @return {boolean} True if `object` is a ReactElement.\n * @final\n */\n" --> (515:2-516:2) "\t}\n\t" +(875:0-875:9) "\nfunction" --> (516:2-516:11) "\tfunction" +(875:9-875:24) " isValidElement" --> (516:11-516:26) " isValidElement" +(875:24-875:32) "(object)" --> (516:26-516:34) "(object)" +(875:32-876:2) " {\n " --> (516:34-517:0) " {" +(876:2-876:16) " return typeof" --> (517:0-517:17) "\n\t\t\treturn typeof" +(876:16-876:27) " object ===" --> (517:17-517:28) " object ===" +(876:27-876:39) " 'object' &&" --> (517:28-517:40) " \"object\" &&" +(876:39-876:50) " object !==" --> (517:40-517:51) " object !==" +(876:50-876:58) " null &&" --> (517:51-517:59) " null &&" +(876:58-876:65) " object" --> (517:59-517:66) " object" +(876:65-876:78) ".$$typeof ===" --> (517:66-517:79) ".$$typeof ===" +(876:78-877:1) " REACT_ELEMENT_TYPE;\n" --> (517:79-518:2) " REACT_ELEMENT_TYPE;\n\t" +(877:1-879:0) "}\n" --> (518:2-519:2) "\t}\n\t" +(879:0-879:4) "\nvar" --> (519:2-519:6) "\tvar" +(879:4-879:16) " SEPARATOR =" --> (519:6-519:18) " SEPARATOR =" +(879:16-880:0) " '.';" --> (519:18-520:2) " \".\";\n\t" +(880:0-880:4) "\nvar" --> (520:2-520:6) "\tvar" +(880:4-880:19) " SUBSEPARATOR =" --> (520:6-520:21) " SUBSEPARATOR =" +(880:19-888:0) " ':';\n/**\n * Escape and wrap key so it is safe to use as a reactid\n *\n * @param {string} key to be escaped.\n * @return {string} the escaped key.\n */\n" --> (520:21-521:2) " \":\";\n\t" +(888:0-888:9) "\nfunction" --> (521:2-521:11) "\tfunction" +(888:9-888:16) " escape" --> (521:11-521:18) " escape" +(888:16-888:21) "(key)" --> (521:18-521:23) "(key)" +(888:21-889:2) " {\n " --> (521:23-522:3) " {\n\t\t" +(889:2-889:6) " var" --> (522:3-522:7) "\tvar" +(889:6-889:20) " escapeRegex =" --> (522:7-522:21) " escapeRegex =" +(889:20-890:2) " /[=:]/g;\n " --> (522:21-523:3) " /[=:]/g;\n\t\t" +(890:2-890:6) " var" --> (523:3-523:7) "\tvar" +(890:6-890:22) " escaperLookup =" --> (523:7-523:23) " escaperLookup =" +(890:22-891:4) " {\n " --> (523:23-524:4) " {\n\t\t\t" +(891:4-891:9) " '=':" --> (524:4-524:9) "\t\"=\":" +(891:9-892:4) " '=0',\n " --> (524:9-525:4) " \"=0\",\n\t\t\t" +(892:4-892:9) " ':':" --> (525:4-525:9) "\t\":\":" +(892:9-893:3) " '=2'\n " --> (525:9-526:3) " \"=2\"\n\t\t" +(893:3-894:2) "};\n " --> (526:3-527:3) "\t};\n\t\t" +(894:2-894:6) " var" --> (527:3-527:7) "\tvar" +(894:6-894:22) " escapedString =" --> (527:7-527:23) " escapedString =" +(894:22-894:26) " key" --> (527:23-527:27) " key" +(894:26-894:34) ".replace" --> (527:27-527:35) ".replace" +(894:34-894:47) "(escapeRegex," --> (527:35-527:48) "(escapeRegex," +(894:47-894:57) " function " --> (527:48-527:57) " function" +(894:57-894:64) "(match)" --> (527:57-527:64) "(match)" +(894:64-895:4) " {\n " --> (527:64-528:0) " {" +(895:4-895:11) " return" --> (528:0-528:11) "\n\t\t\t\treturn" +(895:11-895:25) " escaperLookup" --> (528:11-528:25) " escaperLookup" +(895:25-896:3) "[match];\n " --> (528:25-529:3) "[match];\n\t\t" +(896:3-896:4) "}" --> (529:3-529:5) "\t}" +(896:4-897:2) ");\n " --> (529:5-530:0) ");" +(897:2-897:9) " return" --> (530:0-530:10) "\n\t\t\treturn" +(897:9-897:15) " '$' +" --> (530:10-530:16) " \"$\" +" +(897:15-898:1) " escapedString;\n" --> (530:16-531:2) " escapedString;\n\t" +(898:1-905:0) "}\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\n" --> (531:2-532:2) "\t}\n\t" +(905:0-905:4) "\nvar" --> (532:2-532:6) "\tvar" +(905:4-905:23) " didWarnAboutMaps =" --> (532:6-532:25) " didWarnAboutMaps =" +(905:23-906:0) " false;" --> (532:25-533:2) " false;\n\t" +(906:0-906:4) "\nvar" --> (533:2-533:6) "\tvar" +(906:4-906:33) " userProvidedKeyEscapeRegex =" --> (533:6-533:35) " userProvidedKeyEscapeRegex =" +(906:33-908:0) " /\\/+/g;\n" --> (533:35-534:2) " /\\/+/g;\n\t" +(908:0-908:9) "\nfunction" --> (534:2-534:11) "\tfunction" +(908:9-908:31) " escapeUserProvidedKey" --> (534:11-534:33) " escapeUserProvidedKey" +(908:31-908:37) "(text)" --> (534:33-534:39) "(text)" +(908:37-909:2) " {\n " --> (534:39-535:0) " {" +(909:2-909:9) " return" --> (535:0-535:10) "\n\t\t\treturn" +(909:9-909:14) " text" --> (535:10-535:15) " text" +(909:14-909:22) ".replace" --> (535:15-535:23) ".replace" +(909:22-909:50) "(userProvidedKeyEscapeRegex," --> (535:23-535:51) "(userProvidedKeyEscapeRegex," +(909:50-909:56) " '$&/'" --> (535:51-535:57) " \"$&/\"" +(909:56-910:1) ");\n" --> (535:57-536:2) ");\n\t" +(910:1-920:0) "}\n/**\n * Generate a key string that identifies a element within a set.\n *\n * @param {*} element A element that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\n\n" --> (536:2-537:2) "\t}\n\t" +(920:0-920:9) "\nfunction" --> (537:2-537:11) "\tfunction" +(920:9-920:23) " getElementKey" --> (537:11-537:25) " getElementKey" +(920:23-920:32) "(element," --> (537:25-537:34) "(element," +(920:32-920:39) " index)" --> (537:34-537:41) " index)" +(920:39-923:2) " {\n // Do some typechecking here since we call this blindly. We want to ensure\n // that we don't block potential future ES APIs.\n " --> (537:41-538:0) " {" +(923:2-923:13) " if (typeof" --> (538:0-538:14) "\n\t\t\tif (typeof" +(923:13-923:25) " element ===" --> (538:14-538:26) " element ===" +(923:25-923:37) " 'object' &&" --> (538:26-538:38) " \"object\" &&" +(923:37-923:49) " element !==" --> (538:38-538:50) " element !==" +(923:49-923:57) " null &&" --> (538:50-538:58) " null &&" +(923:57-923:65) " element" --> (538:58-538:66) " element" +(923:65-923:72) ".key !=" --> (538:66-538:73) ".key !=" +(923:72-923:78) " null)" --> (538:73-538:79) " null)" +(923:78-925:4) " {\n // Explicit key\n " --> (538:79-539:0) " {" +(925:4-925:11) " return" --> (539:0-539:11) "\n\t\t\t\treturn" +(925:11-925:18) " escape" --> (539:11-539:18) " escape" +(925:18-925:23) "('' +" --> (539:18-539:23) "(\"\" +" +(925:23-925:31) " element" --> (539:23-539:31) " element" +(925:31-925:35) ".key" --> (539:31-539:35) ".key" +(925:35-926:3) ");\n " --> (539:35-540:3) ");\n\t\t" +(926:3-929:2) "} // Implicit key determined by the index in the set\n\n\n " --> (540:3-541:0) "\t}" +(929:2-929:9) " return" --> (541:0-541:10) "\n\t\t\treturn" +(929:9-929:15) " index" --> (541:10-541:16) " index" +(929:15-929:24) ".toString" --> (541:16-541:25) ".toString" +(929:24-929:27) "(36" --> (541:25-541:28) "(36" +(929:27-930:1) ");\n" --> (541:28-542:2) ");\n\t" +(930:1-932:0) "}\n" --> (542:2-543:2) "\t}\n\t" +(932:0-932:9) "\nfunction" --> (543:2-543:11) "\tfunction" +(932:9-932:22) " mapIntoArray" --> (543:11-543:24) " mapIntoArray" +(932:22-932:32) "(children," --> (543:24-543:34) "(children," +(932:32-932:39) " array," --> (543:34-543:41) " array," +(932:39-932:54) " escapedPrefix," --> (543:41-543:56) " escapedPrefix," +(932:54-932:65) " nameSoFar," --> (543:56-543:67) " nameSoFar," +(932:65-932:75) " callback)" --> (543:67-543:77) " callback)" +(932:75-933:2) " {\n " --> (543:77-544:3) " {\n\t\t" +(933:2-933:6) " var" --> (544:3-544:7) "\tvar" +(933:6-933:20) " type = typeof" --> (544:7-544:21) " type = typeof" +(933:20-935:2) " children;\n\n " --> (544:21-545:0) " children;" +(935:2-935:6) " if " --> (545:0-545:7) "\n\t\t\tif " +(935:6-935:15) "(type ===" --> (545:7-545:16) "(type ===" +(935:15-935:30) " 'undefined' ||" --> (545:16-545:31) " \"undefined\" ||" +(935:30-935:39) " type ===" --> (545:31-545:40) " type ===" +(935:39-935:50) " 'boolean')" --> (545:40-545:51) " \"boolean\")" +(935:50-937:4) " {\n // All of the above are perceived as null.\n " --> (545:51-546:0) " {" +(937:4-937:15) " children =" --> (546:0-546:15) "\n\t\t\t\tchildren =" +(937:15-938:3) " null;\n " --> (546:15-547:3) " null;\n\t\t" +(938:3-940:2) "}\n\n " --> (547:3-548:3) "\t}\n\t\t" +(940:2-940:6) " var" --> (548:3-548:7) "\tvar" +(940:6-940:23) " invokeCallback =" --> (548:7-548:24) " invokeCallback =" +(940:23-942:2) " false;\n\n " --> (548:24-549:0) " false;" +(942:2-942:6) " if " --> (549:0-549:7) "\n\t\t\tif " +(942:6-942:19) "(children ===" --> (549:7-549:20) "(children ===" +(942:19-942:25) " null)" --> (549:20-549:26) " null)" +(942:25-943:4) " {\n " --> (549:26-550:0) " {" +(943:4-943:21) " invokeCallback =" --> (550:0-550:21) "\n\t\t\t\tinvokeCallback =" +(943:21-944:3) " true;\n " --> (550:21-551:3) " true;\n\t\t" +(944:3-944:9) "} else" --> (551:3-551:10) "\t} else" +(944:9-945:4) " {\n " --> (551:10-552:0) " {" +(945:4-945:12) " switch " --> (552:0-552:12) "\n\t\t\t\tswitch " +(945:12-945:4) " switch " --> (552:12-552:18) "(type)" +(945:4-946:6) " switch (type) {\n " --> (552:18-553:0) " {" +(946:6-946:11) " case" --> (553:0-553:10) "\n\t\t\t\t\tcase" +(946:11-947:6) " 'string':\n " --> (553:10-554:0) " \"string\":" +(947:6-947:11) " case" --> (554:0-554:10) "\n\t\t\t\t\tcase" +(947:11-948:8) " 'number':\n " --> (554:10-555:0) " \"number\":" +(948:8-948:25) " invokeCallback =" --> (555:0-555:23) "\n\t\t\t\t\t\tinvokeCallback =" +(948:25-949:8) " true;\n " --> (555:23-556:0) " true;" +(949:8-951:6) " break;\n\n " --> (556:0-557:0) "\n\t\t\t\t\t\tbreak;" +(951:6-951:11) " case" --> (557:0-557:10) "\n\t\t\t\t\tcase" +(951:11-952:8) " 'object':\n " --> (557:10-558:0) " \"object\":" +(952:8-952:16) " switch " --> (558:0-558:14) "\n\t\t\t\t\t\tswitch " +(952:16-952:25) "(children" --> (558:14-558:23) "(children" +(952:25-952:8) " switch (children" --> (558:23-558:33) ".$$typeof)" +(952:8-953:10) " switch (children.$$typeof) {\n " --> (558:33-559:0) " {" +(953:10-953:15) " case" --> (559:0-559:12) "\n\t\t\t\t\t\t\tcase" +(953:15-954:10) " REACT_ELEMENT_TYPE:\n " --> (559:12-560:0) " REACT_ELEMENT_TYPE:" +(954:10-954:15) " case" --> (560:0-560:12) "\n\t\t\t\t\t\t\tcase" +(954:15-955:12) " REACT_PORTAL_TYPE:\n " --> (560:12-561:0) " REACT_PORTAL_TYPE:" +(955:12-955:29) " invokeCallback =" --> (561:0-561:25) "\n\t\t\t\t\t\t\t\tinvokeCallback =" +(955:29-956:9) " true;\n " --> (561:25-562:6) " true;\n\t\t\t\t\t" +(956:9-958:5) "}\n\n " --> (562:6-563:4) "\t}\n\t\t\t" +(958:5-959:3) "}\n " --> (563:4-564:3) "\t}\n\t\t" +(959:3-961:2) "}\n\n " --> (564:3-565:0) "\t}" +(961:2-961:6) " if " --> (565:0-565:7) "\n\t\t\tif " +(961:6-961:22) "(invokeCallback)" --> (565:7-565:23) "(invokeCallback)" +(961:22-962:4) " {\n " --> (565:23-566:4) " {\n\t\t\t" +(962:4-962:8) " var" --> (566:4-566:8) "\tvar" +(962:8-962:17) " _child =" --> (566:8-566:17) " _child =" +(962:17-963:4) " children;\n " --> (566:17-567:4) " children;\n\t\t\t" +(963:4-963:8) " var" --> (567:4-567:8) "\tvar" +(963:8-963:22) " mappedChild =" --> (567:8-567:22) " mappedChild =" +(963:22-963:31) " callback" --> (567:22-567:31) " callback" +(963:31-963:38) "(_child" --> (567:31-567:38) "(_child" +(963:38-966:4) "); // If it's the only child, treat the name as if it was wrapped in an array\n // so that it's consistent if the number of children grows:\n\n " --> (567:38-568:4) ");\n\t\t\t" +(966:4-966:8) " var" --> (568:4-568:8) "\tvar" +(966:8-966:19) " childKey =" --> (568:8-568:19) " childKey =" +(966:19-966:33) " nameSoFar ===" --> (568:19-568:33) " nameSoFar ===" +(966:33-966:38) " '' ?" --> (568:33-568:38) " \"\" ?" +(966:38-966:50) " SEPARATOR +" --> (568:38-568:50) " SEPARATOR +" +(966:50-966:64) " getElementKey" --> (568:50-568:64) " getElementKey" +(966:64-966:72) "(_child," --> (568:64-568:72) "(_child," +(966:72-966:74) " 0" --> (568:72-568:74) " 0" +(966:74-966:77) ") :" --> (568:74-568:77) ") :" +(966:77-968:4) " nameSoFar;\n\n " --> (568:77-569:0) " nameSoFar;" +(968:4-968:8) " if " --> (569:0-569:8) "\n\t\t\t\tif " +(968:8-968:14) "(Array" --> (569:8-569:14) "(Array" +(968:14-968:22) ".isArray" --> (569:14-569:22) ".isArray" +(968:22-968:34) "(mappedChild" --> (569:22-569:34) "(mappedChild" +(968:34-968:36) "))" --> (569:34-569:36) "))" +(968:36-969:6) " {\n " --> (569:36-570:5) " {\n\t\t\t\t" +(969:6-969:10) " var" --> (570:5-570:9) "\tvar" +(969:10-969:28) " escapedChildKey =" --> (570:9-570:27) " escapedChildKey =" +(969:28-971:6) " '';\n\n " --> (570:27-571:0) " \"\";" +(971:6-971:10) " if " --> (571:0-571:9) "\n\t\t\t\t\tif " +(971:10-971:22) "(childKey !=" --> (571:9-571:21) "(childKey !=" +(971:22-971:28) " null)" --> (571:21-571:27) " null)" +(971:28-972:8) " {\n " --> (571:27-572:0) " {" +(972:8-972:26) " escapedChildKey =" --> (572:0-572:24) "\n\t\t\t\t\t\tescapedChildKey =" +(972:26-972:48) " escapeUserProvidedKey" --> (572:24-572:46) " escapeUserProvidedKey" +(972:48-972:57) "(childKey" --> (572:46-572:55) "(childKey" +(972:57-972:60) ") +" --> (572:55-572:58) ") +" +(972:60-973:7) " '/';\n " --> (572:58-573:5) " \"/\";\n\t\t\t\t" +(973:7-975:6) "}\n\n " --> (573:5-574:0) "\t}" +(975:6-975:19) " mapIntoArray" --> (574:0-574:18) "\n\t\t\t\t\tmapIntoArray" +(975:19-975:32) "(mappedChild," --> (574:18-574:31) "(mappedChild," +(975:32-975:39) " array," --> (574:31-574:38) " array," +(975:39-975:56) " escapedChildKey," --> (574:38-574:55) " escapedChildKey," +(975:56-975:60) " ''," --> (574:55-574:59) " \"\"," +(975:60-975:70) " function " --> (574:59-574:68) " function" +(975:70-975:73) "(c)" --> (574:68-574:71) "(c)" +(975:73-976:8) " {\n " --> (574:71-575:0) " {" +(976:8-976:15) " return" --> (575:0-575:13) "\n\t\t\t\t\t\treturn" +(976:15-977:7) " c;\n " --> (575:13-576:5) " c;\n\t\t\t\t" +(977:7-977:8) "}" --> (576:5-576:7) "\t}" +(977:8-978:5) ");\n " --> (576:7-577:4) ");\n\t\t\t" +(978:5-978:15) "} else if " --> (577:4-577:15) "\t} else if " +(978:15-978:30) "(mappedChild !=" --> (577:15-577:30) "(mappedChild !=" +(978:30-978:36) " null)" --> (577:30-577:36) " null)" +(978:36-979:6) " {\n " --> (577:36-578:0) " {" +(979:6-979:10) " if " --> (578:0-578:9) "\n\t\t\t\t\tif " +(979:10-979:25) "(isValidElement" --> (578:9-578:24) "(isValidElement" +(979:25-979:37) "(mappedChild" --> (578:24-578:36) "(mappedChild" +(979:37-979:39) "))" --> (578:36-578:38) "))" +(979:39-980:8) " {\n " --> (578:38-579:0) " {" +(980:8-980:22) " mappedChild =" --> (579:0-579:20) "\n\t\t\t\t\t\tmappedChild =" +(980:22-980:41) " cloneAndReplaceKey" --> (579:20-579:39) " cloneAndReplaceKey" +(980:41-982:8) "(mappedChild, // Keep both the (mapped) and old keys if they differ, just as\n // traverseAllChildren used to do for objects as children\n " --> (579:39-579:52) "(mappedChild," +(982:8-983:8) " escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key\n " --> (579:52-579:69) " escapedPrefix + " +(983:8-983:20) " mappedChild" --> (579:69-579:81) "(mappedChild" +(983:20-983:29) ".key && (" --> (579:81-579:90) ".key && (" +(983:29-983:39) "!_child ||" --> (579:90-579:100) "!_child ||" +(983:39-983:46) " _child" --> (579:100-579:107) " _child" +(983:46-983:54) ".key !==" --> (579:107-579:115) ".key !==" +(983:54-983:66) " mappedChild" --> (579:115-579:127) " mappedChild" +(983:66-984:8) ".key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number\n " --> (579:127-579:134) ".key) ?" +(984:8-984:30) " escapeUserProvidedKey" --> (579:134-579:156) " escapeUserProvidedKey" +(984:30-984:35) "('' +" --> (579:156-579:161) "(\"\" +" +(984:35-984:47) " mappedChild" --> (579:161-579:173) " mappedChild" +(984:47-984:51) ".key" --> (579:173-579:177) ".key" +(984:51-984:54) ") +" --> (579:177-579:180) ") +" +(984:54-984:60) " '/' :" --> (579:180-579:186) " \"/\" :" +(984:60-984:66) " '') +" --> (579:186-579:192) " \"\") +" +(984:66-984:75) " childKey" --> (579:192-579:201) " childKey" +(984:75-985:7) ");\n " --> (579:201-580:5) ");\n\t\t\t\t" +(985:7-987:6) "}\n\n " --> (580:5-581:0) "\t}" +(987:6-987:12) " array" --> (581:0-581:11) "\n\t\t\t\t\tarray" +(987:12-987:17) ".push" --> (581:11-581:16) ".push" +(987:17-987:29) "(mappedChild" --> (581:16-581:28) "(mappedChild" +(987:29-988:5) ");\n " --> (581:28-582:4) ");\n\t\t\t" +(988:5-990:4) "}\n\n " --> (582:4-583:0) "\t}" +(990:4-990:11) " return" --> (583:0-583:11) "\n\t\t\t\treturn" +(990:11-991:3) " 1;\n " --> (583:11-584:3) " 1;\n\t\t" +(991:3-993:2) "}\n\n " --> (584:3-585:3) "\t}\n\t\t" +(993:2-993:6) " var" --> (585:3-585:7) "\tvar" +(993:6-994:2) " child;\n " --> (585:7-586:3) " child;\n\t\t" +(994:2-994:6) " var" --> (586:3-586:7) "\tvar" +(994:6-995:2) " nextName;\n " --> (586:7-587:3) " nextName;\n\t\t" +(995:2-995:6) " var" --> (587:3-587:7) "\tvar" +(995:6-995:21) " subtreeCount =" --> (587:7-587:22) " subtreeCount =" +(995:21-997:2) " 0; // Count of children found in the current subtree.\n\n " --> (587:22-588:3) " 0;\n\t\t" +(997:2-997:6) " var" --> (588:3-588:7) "\tvar" +(997:6-997:23) " nextNamePrefix =" --> (588:7-588:24) " nextNamePrefix =" +(997:23-997:37) " nameSoFar ===" --> (588:24-588:38) " nameSoFar ===" +(997:37-997:42) " '' ?" --> (588:38-588:43) " \"\" ?" +(997:42-997:54) " SEPARATOR :" --> (588:43-588:55) " SEPARATOR :" +(997:54-997:66) " nameSoFar +" --> (588:55-588:67) " nameSoFar +" +(997:66-999:2) " SUBSEPARATOR;\n\n " --> (588:67-589:0) " SUBSEPARATOR;" +(999:2-999:6) " if " --> (589:0-589:7) "\n\t\t\tif " +(999:6-999:12) "(Array" --> (589:7-589:13) "(Array" +(999:12-999:20) ".isArray" --> (589:13-589:21) ".isArray" +(999:20-999:29) "(children" --> (589:21-589:30) "(children" +(999:29-999:31) "))" --> (589:30-589:32) "))" +(999:31-1000:4) " {\n " --> (589:32-590:0) " {" +(1000:4-1000:9) " for " --> (590:0-590:9) "\n\t\t\t\tfor " +(1000:9-1000:13) "(var" --> (590:9-590:13) "(var" +(1000:13-1000:17) " i =" --> (590:13-590:17) " i =" +(1000:17-1000:20) " 0;" --> (590:17-590:20) " 0;" +(1000:20-1000:24) " i <" --> (590:20-590:24) " i <" +(1000:24-1000:33) " children" --> (590:24-590:33) " children" +(1000:33-1000:41) ".length;" --> (590:33-590:41) ".length;" +(1000:41-1000:46) " i++)" --> (590:41-590:46) " i++)" +(1000:46-1001:6) " {\n " --> (590:46-591:0) " {" +(1001:6-1001:14) " child =" --> (591:0-591:13) "\n\t\t\t\t\tchild =" +(1001:14-1001:23) " children" --> (591:13-591:22) " children" +(1001:23-1002:6) "[i];\n " --> (591:22-592:0) "[i];" +(1002:6-1002:17) " nextName =" --> (592:0-592:16) "\n\t\t\t\t\tnextName =" +(1002:17-1002:34) " nextNamePrefix +" --> (592:16-592:33) " nextNamePrefix +" +(1002:34-1002:48) " getElementKey" --> (592:33-592:47) " getElementKey" +(1002:48-1002:55) "(child," --> (592:47-592:54) "(child," +(1002:55-1002:57) " i" --> (592:54-592:56) " i" +(1002:57-1003:6) ");\n " --> (592:56-593:0) ");" +(1003:6-1003:22) " subtreeCount +=" --> (593:0-593:21) "\n\t\t\t\t\tsubtreeCount +=" +(1003:22-1003:35) " mapIntoArray" --> (593:21-593:34) " mapIntoArray" +(1003:35-1003:42) "(child," --> (593:34-593:41) "(child," +(1003:42-1003:49) " array," --> (593:41-593:48) " array," +(1003:49-1003:64) " escapedPrefix," --> (593:48-593:63) " escapedPrefix," +(1003:64-1003:74) " nextName," --> (593:63-593:73) " nextName," +(1003:74-1003:83) " callback" --> (593:73-593:82) " callback" +(1003:83-1004:5) ");\n " --> (593:82-594:4) ");\n\t\t\t" +(1004:5-1005:3) "}\n " --> (594:4-595:3) "\t}\n\t\t" +(1005:3-1005:9) "} else" --> (595:3-595:10) "\t} else" +(1005:9-1006:4) " {\n " --> (595:10-596:4) " {\n\t\t\t" +(1006:4-1006:8) " var" --> (596:4-596:8) "\tvar" +(1006:8-1006:21) " iteratorFn =" --> (596:8-596:21) " iteratorFn =" +(1006:21-1006:35) " getIteratorFn" --> (596:21-596:35) " getIteratorFn" +(1006:35-1006:44) "(children" --> (596:35-596:44) "(children" +(1006:44-1008:4) ");\n\n " --> (596:44-597:0) ");" +(1008:4-1008:15) " if (typeof" --> (597:0-597:15) "\n\t\t\t\tif (typeof" +(1008:15-1008:30) " iteratorFn ===" --> (597:15-597:30) " iteratorFn ===" +(1008:30-1008:42) " 'function')" --> (597:30-597:42) " \"function\")" +(1008:42-1009:6) " {\n " --> (597:42-598:5) " {\n\t\t\t\t" +(1009:6-1009:10) " var" --> (598:5-598:9) "\tvar" +(1009:10-1009:29) " iterableChildren =" --> (598:9-598:28) " iterableChildren =" +(1009:29-1011:6) " children;\n\n " --> (598:28-599:5) " children;\n\t\t\t\t" +(1011:6-1013:8) " {\n // Warn about using Maps as children\n " --> (599:5-600:0) "\t{" +(1013:8-1013:12) " if " --> (600:0-600:10) "\n\t\t\t\t\t\tif " +(1013:12-1013:27) "(iteratorFn ===" --> (600:10-600:25) "(iteratorFn ===" +(1013:27-1013:44) " iterableChildren" --> (600:25-600:42) " iterableChildren" +(1013:44-1013:53) ".entries)" --> (600:42-600:51) ".entries)" +(1013:53-1014:10) " {\n " --> (600:51-601:0) " {" +(1014:10-1014:15) " if (" --> (601:0-601:12) "\n\t\t\t\t\t\t\tif (" +(1014:15-1014:33) "!didWarnAboutMaps)" --> (601:12-601:30) "!didWarnAboutMaps)" +(1014:33-1015:12) " {\n " --> (601:30-602:0) " {" +(1015:12-1015:17) " warn" --> (602:0-602:13) "\n\t\t\t\t\t\t\t\twarn" +(1015:17-1015:63) "('Using Maps as children is not supported. ' +" --> (602:13-602:59) "(\"Using Maps as children is not supported. \" +" +(1015:63-1015:110) " 'Use an array of keyed ReactElements instead.'" --> (602:59-602:106) " \"Use an array of keyed ReactElements instead.\"" +(1015:110-1016:11) ");\n " --> (602:106-603:7) ");\n\t\t\t\t\t\t" +(1016:11-1018:10) "}\n\n " --> (603:7-604:0) "\t}" +(1018:10-1018:29) " didWarnAboutMaps =" --> (604:0-604:26) "\n\t\t\t\t\t\t\tdidWarnAboutMaps =" +(1018:29-1019:9) " true;\n " --> (604:26-605:6) " true;\n\t\t\t\t\t" +(1019:9-1020:7) "}\n " --> (605:6-606:5) "\t}\n\t\t\t\t" +(1020:7-1022:6) "}\n\n " --> (606:5-607:5) "\t}\n\t\t\t\t" +(1022:6-1022:10) " var" --> (607:5-607:9) "\tvar" +(1022:10-1022:21) " iterator =" --> (607:9-607:20) " iterator =" +(1022:21-1022:32) " iteratorFn" --> (607:20-607:31) " iteratorFn" +(1022:32-1022:37) ".call" --> (607:31-607:36) ".call" +(1022:37-1022:54) "(iterableChildren" --> (607:36-607:53) "(iterableChildren" +(1022:54-1023:6) ");\n " --> (607:53-608:5) ");\n\t\t\t\t" +(1023:6-1023:10) " var" --> (608:5-608:9) "\tvar" +(1023:10-1024:6) " step;\n " --> (608:9-609:5) " step;\n\t\t\t\t" +(1024:6-1024:10) " var" --> (609:5-609:9) "\tvar" +(1024:10-1024:15) " ii =" --> (609:9-609:14) " ii =" +(1024:15-1026:6) " 0;\n\n " --> (609:14-610:0) " 0;" +(1026:6-1026:15) " while (!" --> (610:0-610:14) "\n\t\t\t\t\twhile (!" +(1026:15-1026:22) "(step =" --> (610:14-610:21) "(step =" +(1026:22-1026:31) " iterator" --> (610:21-610:30) " iterator" +(1026:31-1026:37) ".next(" --> (610:30-610:36) ".next(" +(1026:37-1026:39) "))" --> (610:36-610:38) "))" +(1026:39-1026:45) ".done)" --> (610:38-610:44) ".done)" +(1026:45-1027:8) " {\n " --> (610:44-611:0) " {" +(1027:8-1027:16) " child =" --> (611:0-611:14) "\n\t\t\t\t\t\tchild =" +(1027:16-1027:21) " step" --> (611:14-611:19) " step" +(1027:21-1028:8) ".value;\n " --> (611:19-612:0) ".value;" +(1028:8-1028:19) " nextName =" --> (612:0-612:17) "\n\t\t\t\t\t\tnextName =" +(1028:19-1028:36) " nextNamePrefix +" --> (612:17-612:34) " nextNamePrefix +" +(1028:36-1028:50) " getElementKey" --> (612:34-612:48) " getElementKey" +(1028:50-1028:57) "(child," --> (612:48-612:55) "(child," +(1028:57-1028:62) " ii++" --> (612:55-612:60) " ii++" +(1028:62-1029:8) ");\n " --> (612:60-613:0) ");" +(1029:8-1029:24) " subtreeCount +=" --> (613:0-613:22) "\n\t\t\t\t\t\tsubtreeCount +=" +(1029:24-1029:37) " mapIntoArray" --> (613:22-613:35) " mapIntoArray" +(1029:37-1029:44) "(child," --> (613:35-613:42) "(child," +(1029:44-1029:51) " array," --> (613:42-613:49) " array," +(1029:51-1029:66) " escapedPrefix," --> (613:49-613:64) " escapedPrefix," +(1029:66-1029:76) " nextName," --> (613:64-613:74) " nextName," +(1029:76-1029:85) " callback" --> (613:74-613:83) " callback" +(1029:85-1030:7) ");\n " --> (613:83-614:5) ");\n\t\t\t\t" +(1030:7-1031:5) "}\n " --> (614:5-615:4) "\t}\n\t\t\t" +(1031:5-1031:15) "} else if " --> (615:4-615:15) "\t} else if " +(1031:15-1031:24) "(type ===" --> (615:15-615:24) "(type ===" +(1031:24-1031:34) " 'object')" --> (615:24-615:34) " \"object\")" +(1031:34-1032:6) " {\n " --> (615:34-616:5) " {\n\t\t\t\t" +(1032:6-1032:10) " var" --> (616:5-616:9) "\tvar" +(1032:10-1032:27) " childrenString =" --> (616:9-616:26) " childrenString =" +(1032:27-1032:32) " '' +" --> (616:26-616:31) " \"\" +" +(1032:32-1034:6) " children;\n\n " --> (616:31-617:5) " children;\n\t\t\t\t" +(1034:6-1035:8) " {\n " --> (617:5-618:6) "\t{\n\t\t\t\t\t" +(1035:8-1036:10) " {\n " --> (618:6-619:0) "\t{" +(1036:10-1036:16) " throw" --> (619:0-619:13) "\n\t\t\t\t\t\t\tthrow" +(1036:16-1036:23) " Error(" --> (619:13-619:19) " Error" +(1036:23-1036:76) " \"Objects are not valid as a React child (found: \" + " --> (619:19-619:72) "(\"Objects are not valid as a React child (found: \" + " +(1036:76-1036:95) "(childrenString ===" --> (619:72-619:91) "(childrenString ===" +(1036:95-1036:115) " '[object Object]' ?" --> (619:91-619:111) " \"[object Object]\" ?" +(1036:115-1036:138) " 'object with keys {' +" --> (619:111-619:134) " \"object with keys {\" +" +(1036:138-1036:145) " Object" --> (619:134-619:141) " Object" +(1036:145-1036:150) ".keys" --> (619:141-619:146) ".keys" +(1036:150-1036:159) "(children" --> (619:146-619:155) "(children" +(1036:159-1036:160) ")" --> (619:155-619:156) ")" +(1036:160-1036:165) ".join" --> (619:156-619:161) ".join" +(1036:165-1036:170) "(', '" --> (619:161-619:166) "(\", \"" +(1036:170-1036:173) ") +" --> (619:166-619:169) ") +" +(1036:173-1036:179) " '}' :" --> (619:169-619:175) " \"}\" :" +(1036:179-1036:197) " childrenString) +" --> (619:175-619:193) " childrenString) +" +(1036:197-1036:274) " \"). If you meant to render a collection of children, use an array instead.\" " --> (619:193-619:269) " \"). If you meant to render a collection of children, use an array instead.\"" +(1036:274-1037:9) ");\n " --> (619:269-620:6) ");\n\t\t\t\t\t" +(1037:9-1038:7) "}\n " --> (620:6-621:5) "\t}\n\t\t\t\t" +(1038:7-1039:5) "}\n " --> (621:5-622:4) "\t}\n\t\t\t" +(1039:5-1040:3) "}\n " --> (622:4-623:3) "\t}\n\t\t" +(1040:3-1042:2) "}\n\n " --> (623:3-624:0) "\t}" +(1042:2-1042:9) " return" --> (624:0-624:10) "\n\t\t\treturn" +(1042:9-1043:1) " subtreeCount;\n" --> (624:10-625:2) " subtreeCount;\n\t" +(1043:1-1058:0) "}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\n *\n * The provided mapFunction(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} func The map function.\n * @param {*} context Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */" --> (625:2-626:2) "\t}\n\t" +(1058:0-1058:9) "\nfunction" --> (626:2-626:11) "\tfunction" +(1058:9-1058:21) " mapChildren" --> (626:11-626:23) " mapChildren" +(1058:21-1058:31) "(children," --> (626:23-626:33) "(children," +(1058:31-1058:37) " func," --> (626:33-626:39) " func," +(1058:37-1058:46) " context)" --> (626:39-626:48) " context)" +(1058:46-1059:2) " {\n " --> (626:48-627:0) " {" +(1059:2-1059:6) " if " --> (627:0-627:7) "\n\t\t\tif " +(1059:6-1059:18) "(children ==" --> (627:7-627:19) "(children ==" +(1059:18-1059:24) " null)" --> (627:19-627:25) " null)" +(1059:24-1060:4) " {\n " --> (627:25-628:0) " {" +(1060:4-1060:11) " return" --> (628:0-628:11) "\n\t\t\t\treturn" +(1060:11-1061:3) " children;\n " --> (628:11-629:3) " children;\n\t\t" +(1061:3-1063:2) "}\n\n " --> (629:3-630:3) "\t}\n\t\t" +(1063:2-1063:6) " var" --> (630:3-630:7) "\tvar" +(1063:6-1063:15) " result =" --> (630:7-630:16) " result =" +(1063:15-1063:17) " [" --> (630:16-630:18) " [" +(1063:17-1064:2) "];\n " --> (630:18-631:3) "];\n\t\t" +(1064:2-1064:6) " var" --> (631:3-631:7) "\tvar" +(1064:6-1064:14) " count =" --> (631:7-631:15) " count =" +(1064:14-1065:2) " 0;\n " --> (631:15-632:0) " 0;" +(1065:2-1065:15) " mapIntoArray" --> (632:0-632:16) "\n\t\t\tmapIntoArray" +(1065:15-1065:25) "(children," --> (632:16-632:26) "(children," +(1065:25-1065:33) " result," --> (632:26-632:34) " result," +(1065:33-1065:37) " ''," --> (632:34-632:38) " \"\"," +(1065:37-1065:41) " ''," --> (632:38-632:42) " \"\"," +(1065:41-1065:51) " function " --> (632:42-632:51) " function" +(1065:51-1065:58) "(child)" --> (632:51-632:58) "(child)" +(1065:58-1066:4) " {\n " --> (632:58-633:0) " {" +(1066:4-1066:11) " return" --> (633:0-633:11) "\n\t\t\t\treturn" +(1066:11-1066:16) " func" --> (633:11-633:16) " func" +(1066:16-1066:21) ".call" --> (633:16-633:21) ".call" +(1066:21-1066:30) "(context," --> (633:21-633:30) "(context," +(1066:30-1066:37) " child," --> (633:30-633:37) " child," +(1066:37-1066:45) " count++" --> (633:37-633:45) " count++" +(1066:45-1067:3) ");\n " --> (633:45-634:3) ");\n\t\t" +(1067:3-1067:4) "}" --> (634:3-634:5) "\t}" +(1067:4-1068:2) ");\n " --> (634:5-635:0) ");" +(1068:2-1068:9) " return" --> (635:0-635:10) "\n\t\t\treturn" +(1068:9-1069:1) " result;\n" --> (635:10-636:2) " result;\n\t" +(1069:1-1081:0) "}\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\n\n" --> (636:2-637:2) "\t}\n\t" +(1081:0-1081:9) "\nfunction" --> (637:2-637:11) "\tfunction" +(1081:9-1081:23) " countChildren" --> (637:11-637:25) " countChildren" +(1081:23-1081:33) "(children)" --> (637:25-637:35) "(children)" +(1081:33-1082:2) " {\n " --> (637:35-638:3) " {\n\t\t" +(1082:2-1082:6) " var" --> (638:3-638:7) "\tvar" +(1082:6-1082:10) " n =" --> (638:7-638:11) " n =" +(1082:10-1083:2) " 0;\n " --> (638:11-639:0) " 0;" +(1083:2-1083:14) " mapChildren" --> (639:0-639:15) "\n\t\t\tmapChildren" +(1083:14-1083:24) "(children," --> (639:15-639:25) "(children," +(1083:24-1083:36) " function ()" --> (639:25-639:36) " function()" +(1083:36-1084:4) " {\n " --> (639:36-640:0) " {" +(1084:4-1085:3) " n++; // Don't return anything\n " --> (640:0-641:3) "\n\t\t\t\tn++;\n\t\t" +(1085:3-1085:4) "}" --> (641:3-641:5) "\t}" +(1085:4-1086:2) ");\n " --> (641:5-642:0) ");" +(1086:2-1086:9) " return" --> (642:0-642:10) "\n\t\t\treturn" +(1086:9-1087:1) " n;\n" --> (642:10-643:2) " n;\n\t" +(1087:1-1101:0) "}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc\n * @param {*} forEachContext Context for forEachContext.\n */" --> (643:2-644:2) "\t}\n\t" +(1101:0-1101:9) "\nfunction" --> (644:2-644:11) "\tfunction" +(1101:9-1101:25) " forEachChildren" --> (644:11-644:27) " forEachChildren" +(1101:25-1101:35) "(children," --> (644:27-644:37) "(children," +(1101:35-1101:48) " forEachFunc," --> (644:37-644:50) " forEachFunc," +(1101:48-1101:64) " forEachContext)" --> (644:50-644:66) " forEachContext)" +(1101:64-1102:2) " {\n " --> (644:66-645:0) " {" +(1102:2-1102:14) " mapChildren" --> (645:0-645:15) "\n\t\t\tmapChildren" +(1102:14-1102:24) "(children," --> (645:15-645:25) "(children," +(1102:24-1102:36) " function ()" --> (645:25-645:36) " function()" +(1102:36-1103:4) " {\n " --> (645:36-646:0) " {" +(1103:4-1103:16) " forEachFunc" --> (646:0-646:16) "\n\t\t\t\tforEachFunc" +(1103:16-1103:22) ".apply" --> (646:16-646:22) ".apply" +(1103:22-1103:28) "(this," --> (646:22-646:28) "(this," +(1103:28-1103:38) " arguments" --> (646:28-646:38) " arguments" +(1103:38-1104:3) "); // Don't return anything.\n " --> (646:38-647:3) ");\n\t\t" +(1104:3-1104:5) "}," --> (647:3-647:6) "\t}," +(1104:5-1104:20) " forEachContext" --> (647:6-647:21) " forEachContext" +(1104:20-1105:1) ");\n" --> (647:21-648:2) ");\n\t" +(1105:1-1114:0) "}\n/**\n * Flatten a children object (typically specified as `props.children`) and\n * return an array with appropriately re-keyed children.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\n */\n\n" --> (648:2-649:2) "\t}\n\t" +(1114:0-1114:9) "\nfunction" --> (649:2-649:11) "\tfunction" +(1114:9-1114:17) " toArray" --> (649:11-649:19) " toArray" +(1114:17-1114:27) "(children)" --> (649:19-649:29) "(children)" +(1114:27-1115:2) " {\n " --> (649:29-650:0) " {" +(1115:2-1115:9) " return" --> (650:0-650:10) "\n\t\t\treturn" +(1115:9-1115:21) " mapChildren" --> (650:10-650:22) " mapChildren" +(1115:21-1115:31) "(children," --> (650:22-650:32) "(children," +(1115:31-1115:41) " function " --> (650:32-650:41) " function" +(1115:41-1115:48) "(child)" --> (650:41-650:48) "(child)" +(1115:48-1116:4) " {\n " --> (650:48-651:0) " {" +(1116:4-1116:11) " return" --> (651:0-651:11) "\n\t\t\t\treturn" +(1116:11-1117:3) " child;\n " --> (651:11-652:3) " child;\n\t\t" +(1117:3-1117:4) "}" --> (652:3-652:5) "\t}" +(1117:4-1117:8) ") ||" --> (652:5-652:9) ") ||" +(1117:8-1117:10) " [" --> (652:9-652:11) " [" +(1117:10-1118:1) "];\n" --> (652:11-653:2) "];\n\t" +(1118:1-1135:0) "}\n/**\n * Returns the first child in a collection of children and verifies that there\n * is only one child in the collection.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\n *\n * The current implementation of this function assumes that a single child gets\n * passed without a wrapper, but the purpose of this helper function is to\n * abstract away the particular structure of children.\n *\n * @param {?object} children Child collection structure.\n * @return {ReactElement} The first and only `ReactElement` contained in the\n * structure.\n */\n\n" --> (653:2-654:2) "\t}\n\t" +(1135:0-1135:9) "\nfunction" --> (654:2-654:11) "\tfunction" +(1135:9-1135:19) " onlyChild" --> (654:11-654:21) " onlyChild" +(1135:19-1135:29) "(children)" --> (654:21-654:31) "(children)" +(1135:29-1136:2) " {\n " --> (654:31-655:0) " {" +(1136:2-1136:7) " if (" --> (655:0-655:8) "\n\t\t\tif (" +(1136:7-1136:22) "!isValidElement" --> (655:8-655:23) "!isValidElement" +(1136:22-1136:31) "(children" --> (655:23-655:32) "(children" +(1136:31-1136:33) "))" --> (655:32-655:34) "))" +(1136:33-1137:4) " {\n " --> (655:34-656:4) " {\n\t\t\t" +(1137:4-1138:6) " {\n " --> (656:4-657:0) "\t{" +(1138:6-1138:12) " throw" --> (657:0-657:11) "\n\t\t\t\t\tthrow" +(1138:12-1138:19) " Error(" --> (657:11-657:17) " Error" +(1138:19-1138:92) " \"React.Children.only expected to receive a single React element child.\" " --> (657:17-657:89) "(\"React.Children.only expected to receive a single React element child.\"" +(1138:92-1139:5) ");\n " --> (657:89-658:4) ");\n\t\t\t" +(1139:5-1140:3) "}\n " --> (658:4-659:3) "\t}\n\t\t" +(1140:3-1142:2) "}\n\n " --> (659:3-660:0) "\t}" +(1142:2-1142:9) " return" --> (660:0-660:10) "\n\t\t\treturn" +(1142:9-1143:1) " children;\n" --> (660:10-661:2) " children;\n\t" +(1143:1-1145:0) "}\n" --> (661:2-662:2) "\t}\n\t" +(1145:0-1145:9) "\nfunction" --> (662:2-662:11) "\tfunction" +(1145:9-1145:23) " createContext" --> (662:11-662:25) " createContext" +(1145:23-1145:37) "(defaultValue," --> (662:25-662:39) "(defaultValue," +(1145:37-1145:59) " calculateChangedBits)" --> (662:39-662:61) " calculateChangedBits)" +(1145:59-1146:2) " {\n " --> (662:61-663:0) " {" +(1146:2-1146:6) " if " --> (663:0-663:7) "\n\t\t\tif " +(1146:6-1146:31) "(calculateChangedBits ===" --> (663:7-663:32) "(calculateChangedBits ===" +(1146:31-1146:42) " undefined)" --> (663:32-663:43) " undefined)" +(1146:42-1147:4) " {\n " --> (663:43-664:0) " {" +(1147:4-1147:27) " calculateChangedBits =" --> (664:0-664:27) "\n\t\t\t\tcalculateChangedBits =" +(1147:27-1148:3) " null;\n " --> (664:27-665:3) " null;\n\t\t" +(1148:3-1148:9) "} else" --> (665:3-665:10) "\t} else" +(1148:9-1149:4) " {\n " --> (665:10-666:4) " {\n\t\t\t" +(1149:4-1150:6) " {\n " --> (666:4-667:0) "\t{" +(1150:6-1150:10) " if " --> (667:0-667:9) "\n\t\t\t\t\tif " +(1150:10-1150:35) "(calculateChangedBits !==" --> (667:9-667:34) "(calculateChangedBits !==" +(1150:35-1150:50) " null && typeof" --> (667:34-667:49) " null && typeof" +(1150:50-1150:75) " calculateChangedBits !==" --> (667:49-667:74) " calculateChangedBits !==" +(1150:75-1150:87) " 'function')" --> (667:74-667:86) " \"function\")" +(1150:87-1151:8) " {\n " --> (667:86-668:0) " {" +(1151:8-1151:14) " error" --> (668:0-668:12) "\n\t\t\t\t\t\terror" +(1151:14-1151:80) "('createContext: Expected the optional second argument to be a ' +" --> (668:12-668:78) "(\"createContext: Expected the optional second argument to be a \" +" +(1151:80-1151:114) " 'function. Instead received: %s'," --> (668:78-668:112) " \"function. Instead received: %s\"," +(1151:114-1151:135) " calculateChangedBits" --> (668:112-668:133) " calculateChangedBits" +(1151:135-1152:7) ");\n " --> (668:133-669:5) ");\n\t\t\t\t" +(1152:7-1153:5) "}\n " --> (669:5-670:4) "\t}\n\t\t\t" +(1153:5-1154:3) "}\n " --> (670:4-671:3) "\t}\n\t\t" +(1154:3-1156:2) "}\n\n " --> (671:3-672:3) "\t}\n\t\t" +(1156:2-1156:6) " var" --> (672:3-672:7) "\tvar" +(1156:6-1156:16) " context =" --> (672:7-672:17) " context =" +(1156:16-1157:4) " {\n " --> (672:17-673:4) " {\n\t\t\t" +(1157:4-1157:14) " $$typeof:" --> (673:4-673:14) "\t$$typeof:" +(1157:14-1158:4) " REACT_CONTEXT_TYPE,\n " --> (673:14-674:4) " REACT_CONTEXT_TYPE,\n\t\t\t" +(1158:4-1158:27) " _calculateChangedBits:" --> (674:4-674:27) "\t_calculateChangedBits:" +(1158:27-1164:4) " calculateChangedBits,\n // As a workaround to support multiple concurrent renderers, we categorize\n // some renderers as primary and others as secondary. We only expect\n // there to be two concurrent renderers at most: React Native (primary) and\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\n // Secondary renderers store their context values on separate fields.\n " --> (674:27-675:4) " calculateChangedBits,\n\t\t\t" +(1164:4-1164:19) " _currentValue:" --> (675:4-675:19) "\t_currentValue:" +(1164:19-1165:4) " defaultValue,\n " --> (675:19-676:4) " defaultValue,\n\t\t\t" +(1165:4-1165:20) " _currentValue2:" --> (676:4-676:20) "\t_currentValue2:" +(1165:20-1168:4) " defaultValue,\n // Used to track how many concurrent renderers this context currently\n // supports within in a single renderer. Such as parallel server rendering.\n " --> (676:20-677:4) " defaultValue,\n\t\t\t" +(1168:4-1168:18) " _threadCount:" --> (677:4-677:18) "\t_threadCount:" +(1168:18-1170:4) " 0,\n // These are circular\n " --> (677:18-678:4) " 0,\n\t\t\t" +(1170:4-1170:14) " Provider:" --> (678:4-678:14) "\tProvider:" +(1170:14-1171:4) " null,\n " --> (678:14-679:4) " null,\n\t\t\t" +(1171:4-1171:14) " Consumer:" --> (679:4-679:14) "\tConsumer:" +(1171:14-1172:3) " null\n " --> (679:14-680:3) " null\n\t\t" +(1172:3-1173:2) "};\n " --> (680:3-681:0) "\t};" +(1173:2-1173:10) " context" --> (681:0-681:11) "\n\t\t\tcontext" +(1173:10-1173:21) ".Provider =" --> (681:11-681:22) ".Provider =" +(1173:21-1174:4) " {\n " --> (681:22-682:4) " {\n\t\t\t" +(1174:4-1174:14) " $$typeof:" --> (682:4-682:14) "\t$$typeof:" +(1174:14-1175:4) " REACT_PROVIDER_TYPE,\n " --> (682:14-683:4) " REACT_PROVIDER_TYPE,\n\t\t\t" +(1175:4-1175:14) " _context:" --> (683:4-683:14) "\t_context:" +(1175:14-1176:3) " context\n " --> (683:14-684:3) " context\n\t\t" +(1176:3-1177:2) "};\n " --> (684:3-685:3) "\t};\n\t\t" +(1177:2-1177:6) " var" --> (685:3-685:7) "\tvar" +(1177:6-1177:50) " hasWarnedAboutUsingNestedContextConsumers =" --> (685:7-685:51) " hasWarnedAboutUsingNestedContextConsumers =" +(1177:50-1178:2) " false;\n " --> (685:51-686:3) " false;\n\t\t" +(1178:2-1178:6) " var" --> (686:3-686:7) "\tvar" +(1178:6-1178:44) " hasWarnedAboutUsingConsumerProvider =" --> (686:7-686:45) " hasWarnedAboutUsingConsumerProvider =" +(1178:44-1179:2) " false;\n " --> (686:45-687:3) " false;\n\t\t" +(1179:2-1179:6) " var" --> (687:3-687:7) "\tvar" +(1179:6-1179:44) " hasWarnedAboutDisplayNameOnConsumer =" --> (687:7-687:45) " hasWarnedAboutDisplayNameOnConsumer =" +(1179:44-1181:2) " false;\n\n " --> (687:45-688:3) " false;\n\t\t" +(1181:2-1185:4) " {\n // A separate object, but proxies back to the original context object for\n // backwards compatibility. It has a different $$typeof, so we can properly\n // warn for the incorrect usage of Context as a Consumer.\n " --> (688:3-689:4) "\t{\n\t\t\t" +(1185:4-1185:8) " var" --> (689:4-689:8) "\tvar" +(1185:8-1185:19) " Consumer =" --> (689:8-689:19) " Consumer =" +(1185:19-1186:6) " {\n " --> (689:19-690:5) " {\n\t\t\t\t" +(1186:6-1186:16) " $$typeof:" --> (690:5-690:15) "\t$$typeof:" +(1186:16-1187:6) " REACT_CONTEXT_TYPE,\n " --> (690:15-691:5) " REACT_CONTEXT_TYPE,\n\t\t\t\t" +(1187:6-1187:16) " _context:" --> (691:5-691:15) "\t_context:" +(1187:16-1188:6) " context,\n " --> (691:15-692:5) " context,\n\t\t\t\t" +(1188:6-1188:29) " _calculateChangedBits:" --> (692:5-692:28) "\t_calculateChangedBits:" +(1188:29-1188:37) " context" --> (692:28-692:36) " context" +(1188:37-1189:5) "._calculateChangedBits\n " --> (692:36-693:4) "._calculateChangedBits\n\t\t\t" +(1189:5-1191:4) "}; // $FlowFixMe: Flow complains about not setting a value, which is intentional here\n\n " --> (693:4-694:0) "\t};" +(1191:4-1191:11) " Object" --> (694:0-694:11) "\n\t\t\t\tObject" +(1191:11-1191:28) ".defineProperties" --> (694:11-694:28) ".defineProperties" +(1191:28-1191:38) "(Consumer," --> (694:28-694:38) "(Consumer," +(1191:38-1192:6) " {\n " --> (694:38-695:5) " {\n\t\t\t\t" +(1192:6-1192:16) " Provider:" --> (695:5-695:15) "\tProvider:" +(1192:16-1193:8) " {\n " --> (695:15-696:6) " {\n\t\t\t\t\t" +(1193:8-1193:13) " get:" --> (696:6-696:11) "\tget:" +(1193:13-1193:25) " function ()" --> (696:11-696:22) " function()" +(1193:25-1194:10) " {\n " --> (696:22-697:0) " {" +(1194:10-1194:15) " if (" --> (697:0-697:12) "\n\t\t\t\t\t\t\tif (" +(1194:15-1194:52) "!hasWarnedAboutUsingConsumerProvider)" --> (697:12-697:49) "!hasWarnedAboutUsingConsumerProvider)" +(1194:52-1195:12) " {\n " --> (697:49-698:0) " {" +(1195:12-1195:50) " hasWarnedAboutUsingConsumerProvider =" --> (698:0-698:46) "\n\t\t\t\t\t\t\t\thasWarnedAboutUsingConsumerProvider =" +(1195:50-1197:12) " true;\n\n " --> (698:46-699:0) " true;" +(1197:12-1197:18) " error" --> (699:0-699:14) "\n\t\t\t\t\t\t\t\terror" +(1197:18-1197:101) "('Rendering is not supported and will be removed in ' +" --> (699:14-699:97) "(\"Rendering is not supported and will be removed in \" +" +(1197:101-1197:178) " 'a future major release. Did you mean to render instead?'" --> (699:97-699:174) " \"a future major release. Did you mean to render instead?\"" +(1197:178-1198:11) ");\n " --> (699:174-700:7) ");\n\t\t\t\t\t\t" +(1198:11-1200:10) "}\n\n " --> (700:7-701:0) "\t}" +(1200:10-1200:17) " return" --> (701:0-701:14) "\n\t\t\t\t\t\t\treturn" +(1200:17-1200:25) " context" --> (701:14-701:22) " context" +(1200:25-1201:9) ".Provider;\n " --> (701:22-702:6) ".Provider;\n\t\t\t\t\t" +(1201:9-1202:8) "},\n " --> (702:6-703:6) "\t},\n\t\t\t\t\t" +(1202:8-1202:13) " set:" --> (703:6-703:11) "\tset:" +(1202:13-1202:23) " function " --> (703:11-703:20) " function" +(1202:23-1202:34) "(_Provider)" --> (703:20-703:31) "(_Provider)" +(1202:34-1203:10) " {\n " --> (703:31-704:0) " {" +(1203:10-1203:18) " context" --> (704:0-704:15) "\n\t\t\t\t\t\t\tcontext" +(1203:18-1203:29) ".Provider =" --> (704:15-704:26) ".Provider =" +(1203:29-1204:9) " _Provider;\n " --> (704:26-705:6) " _Provider;\n\t\t\t\t\t" +(1204:9-1205:7) "}\n " --> (705:6-706:5) "\t}\n\t\t\t\t" +(1205:7-1206:6) "},\n " --> (706:5-707:5) "\t},\n\t\t\t\t" +(1206:6-1206:21) " _currentValue:" --> (707:5-707:20) "\t_currentValue:" +(1206:21-1207:8) " {\n " --> (707:20-708:6) " {\n\t\t\t\t\t" +(1207:8-1207:13) " get:" --> (708:6-708:11) "\tget:" +(1207:13-1207:25) " function ()" --> (708:11-708:22) " function()" +(1207:25-1208:10) " {\n " --> (708:22-709:0) " {" +(1208:10-1208:17) " return" --> (709:0-709:14) "\n\t\t\t\t\t\t\treturn" +(1208:17-1208:25) " context" --> (709:14-709:22) " context" +(1208:25-1209:9) "._currentValue;\n " --> (709:22-710:6) "._currentValue;\n\t\t\t\t\t" +(1209:9-1210:8) "},\n " --> (710:6-711:6) "\t},\n\t\t\t\t\t" +(1210:8-1210:13) " set:" --> (711:6-711:11) "\tset:" +(1210:13-1210:23) " function " --> (711:11-711:20) " function" +(1210:23-1210:38) "(_currentValue)" --> (711:20-711:35) "(_currentValue)" +(1210:38-1211:10) " {\n " --> (711:35-712:0) " {" +(1211:10-1211:18) " context" --> (712:0-712:15) "\n\t\t\t\t\t\t\tcontext" +(1211:18-1211:34) "._currentValue =" --> (712:15-712:31) "._currentValue =" +(1211:34-1212:9) " _currentValue;\n " --> (712:31-713:6) " _currentValue;\n\t\t\t\t\t" +(1212:9-1213:7) "}\n " --> (713:6-714:5) "\t}\n\t\t\t\t" +(1213:7-1214:6) "},\n " --> (714:5-715:5) "\t},\n\t\t\t\t" +(1214:6-1214:22) " _currentValue2:" --> (715:5-715:21) "\t_currentValue2:" +(1214:22-1215:8) " {\n " --> (715:21-716:6) " {\n\t\t\t\t\t" +(1215:8-1215:13) " get:" --> (716:6-716:11) "\tget:" +(1215:13-1215:25) " function ()" --> (716:11-716:22) " function()" +(1215:25-1216:10) " {\n " --> (716:22-717:0) " {" +(1216:10-1216:17) " return" --> (717:0-717:14) "\n\t\t\t\t\t\t\treturn" +(1216:17-1216:25) " context" --> (717:14-717:22) " context" +(1216:25-1217:9) "._currentValue2;\n " --> (717:22-718:6) "._currentValue2;\n\t\t\t\t\t" +(1217:9-1218:8) "},\n " --> (718:6-719:6) "\t},\n\t\t\t\t\t" +(1218:8-1218:13) " set:" --> (719:6-719:11) "\tset:" +(1218:13-1218:23) " function " --> (719:11-719:20) " function" +(1218:23-1218:39) "(_currentValue2)" --> (719:20-719:36) "(_currentValue2)" +(1218:39-1219:10) " {\n " --> (719:36-720:0) " {" +(1219:10-1219:18) " context" --> (720:0-720:15) "\n\t\t\t\t\t\t\tcontext" +(1219:18-1219:35) "._currentValue2 =" --> (720:15-720:32) "._currentValue2 =" +(1219:35-1220:9) " _currentValue2;\n " --> (720:32-721:6) " _currentValue2;\n\t\t\t\t\t" +(1220:9-1221:7) "}\n " --> (721:6-722:5) "\t}\n\t\t\t\t" +(1221:7-1222:6) "},\n " --> (722:5-723:5) "\t},\n\t\t\t\t" +(1222:6-1222:20) " _threadCount:" --> (723:5-723:19) "\t_threadCount:" +(1222:20-1223:8) " {\n " --> (723:19-724:6) " {\n\t\t\t\t\t" +(1223:8-1223:13) " get:" --> (724:6-724:11) "\tget:" +(1223:13-1223:25) " function ()" --> (724:11-724:22) " function()" +(1223:25-1224:10) " {\n " --> (724:22-725:0) " {" +(1224:10-1224:17) " return" --> (725:0-725:14) "\n\t\t\t\t\t\t\treturn" +(1224:17-1224:25) " context" --> (725:14-725:22) " context" +(1224:25-1225:9) "._threadCount;\n " --> (725:22-726:6) "._threadCount;\n\t\t\t\t\t" +(1225:9-1226:8) "},\n " --> (726:6-727:6) "\t},\n\t\t\t\t\t" +(1226:8-1226:13) " set:" --> (727:6-727:11) "\tset:" +(1226:13-1226:23) " function " --> (727:11-727:20) " function" +(1226:23-1226:37) "(_threadCount)" --> (727:20-727:34) "(_threadCount)" +(1226:37-1227:10) " {\n " --> (727:34-728:0) " {" +(1227:10-1227:18) " context" --> (728:0-728:15) "\n\t\t\t\t\t\t\tcontext" +(1227:18-1227:33) "._threadCount =" --> (728:15-728:30) "._threadCount =" +(1227:33-1228:9) " _threadCount;\n " --> (728:30-729:6) " _threadCount;\n\t\t\t\t\t" +(1228:9-1229:7) "}\n " --> (729:6-730:5) "\t}\n\t\t\t\t" +(1229:7-1230:6) "},\n " --> (730:5-731:5) "\t},\n\t\t\t\t" +(1230:6-1230:16) " Consumer:" --> (731:5-731:15) "\tConsumer:" +(1230:16-1231:8) " {\n " --> (731:15-732:6) " {\n\t\t\t\t\t" +(1231:8-1231:13) " get:" --> (732:6-732:11) "\tget:" +(1231:13-1231:25) " function ()" --> (732:11-732:22) " function()" +(1231:25-1232:10) " {\n " --> (732:22-733:0) " {" +(1232:10-1232:15) " if (" --> (733:0-733:12) "\n\t\t\t\t\t\t\tif (" +(1232:15-1232:58) "!hasWarnedAboutUsingNestedContextConsumers)" --> (733:12-733:55) "!hasWarnedAboutUsingNestedContextConsumers)" +(1232:58-1233:12) " {\n " --> (733:55-734:0) " {" +(1233:12-1233:56) " hasWarnedAboutUsingNestedContextConsumers =" --> (734:0-734:52) "\n\t\t\t\t\t\t\t\thasWarnedAboutUsingNestedContextConsumers =" +(1233:56-1235:12) " true;\n\n " --> (734:52-735:0) " true;" +(1235:12-1235:18) " error" --> (735:0-735:14) "\n\t\t\t\t\t\t\t\terror" +(1235:18-1235:101) "('Rendering is not supported and will be removed in ' +" --> (735:14-735:97) "(\"Rendering is not supported and will be removed in \" +" +(1235:101-1235:178) " 'a future major release. Did you mean to render instead?'" --> (735:97-735:174) " \"a future major release. Did you mean to render instead?\"" +(1235:178-1236:11) ");\n " --> (735:174-736:7) ");\n\t\t\t\t\t\t" +(1236:11-1238:10) "}\n\n " --> (736:7-737:0) "\t}" +(1238:10-1238:17) " return" --> (737:0-737:14) "\n\t\t\t\t\t\t\treturn" +(1238:17-1238:25) " context" --> (737:14-737:22) " context" +(1238:25-1239:9) ".Consumer;\n " --> (737:22-738:6) ".Consumer;\n\t\t\t\t\t" +(1239:9-1240:7) "}\n " --> (738:6-739:5) "\t}\n\t\t\t\t" +(1240:7-1241:6) "},\n " --> (739:5-740:5) "\t},\n\t\t\t\t" +(1241:6-1241:19) " displayName:" --> (740:5-740:18) "\tdisplayName:" +(1241:19-1242:8) " {\n " --> (740:18-741:6) " {\n\t\t\t\t\t" +(1242:8-1242:13) " get:" --> (741:6-741:11) "\tget:" +(1242:13-1242:25) " function ()" --> (741:11-741:22) " function()" +(1242:25-1243:10) " {\n " --> (741:22-742:0) " {" +(1243:10-1243:17) " return" --> (742:0-742:14) "\n\t\t\t\t\t\t\treturn" +(1243:17-1243:25) " context" --> (742:14-742:22) " context" +(1243:25-1244:9) ".displayName;\n " --> (742:22-743:6) ".displayName;\n\t\t\t\t\t" +(1244:9-1245:8) "},\n " --> (743:6-744:6) "\t},\n\t\t\t\t\t" +(1245:8-1245:13) " set:" --> (744:6-744:11) "\tset:" +(1245:13-1245:23) " function " --> (744:11-744:20) " function" +(1245:23-1245:36) "(displayName)" --> (744:20-744:33) "(displayName)" +(1245:36-1246:10) " {\n " --> (744:33-745:0) " {" +(1246:10-1246:15) " if (" --> (745:0-745:12) "\n\t\t\t\t\t\t\tif (" +(1246:15-1246:52) "!hasWarnedAboutDisplayNameOnConsumer)" --> (745:12-745:49) "!hasWarnedAboutDisplayNameOnConsumer)" +(1246:52-1247:12) " {\n " --> (745:49-746:0) " {" +(1247:12-1247:17) " warn" --> (746:0-746:13) "\n\t\t\t\t\t\t\t\twarn" +(1247:17-1247:79) "('Setting `displayName` on Context.Consumer has no effect. ' +" --> (746:13-746:75) "(\"Setting `displayName` on Context.Consumer has no effect. \" +" +(1247:79-1247:157) " \"You should set it directly on the context with Context.displayName = '%s'.\"," --> (746:75-746:153) " \"You should set it directly on the context with Context.displayName = '%s'.\"," +(1247:157-1247:169) " displayName" --> (746:153-746:165) " displayName" +(1247:169-1249:12) ");\n\n " --> (746:165-747:0) ");" +(1249:12-1249:50) " hasWarnedAboutDisplayNameOnConsumer =" --> (747:0-747:46) "\n\t\t\t\t\t\t\t\thasWarnedAboutDisplayNameOnConsumer =" +(1249:50-1250:11) " true;\n " --> (747:46-748:7) " true;\n\t\t\t\t\t\t" +(1250:11-1251:9) "}\n " --> (748:7-749:6) "\t}\n\t\t\t\t\t" +(1251:9-1252:7) "}\n " --> (749:6-750:5) "\t}\n\t\t\t\t" +(1252:7-1253:5) "}\n " --> (750:5-751:4) "\t}\n\t\t\t" +(1253:5-1253:6) "}" --> (751:4-751:6) "\t}" +(1253:6-1255:4) "); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\n\n " --> (751:6-752:0) ");" +(1255:4-1255:12) " context" --> (752:0-752:12) "\n\t\t\t\tcontext" +(1255:12-1255:23) ".Consumer =" --> (752:12-752:23) ".Consumer =" +(1255:23-1256:3) " Consumer;\n " --> (752:23-753:3) " Consumer;\n\t\t" +(1256:3-1258:2) "}\n\n " --> (753:3-754:3) "\t}\n\t\t" +(1258:2-1259:4) " {\n " --> (754:3-755:0) "\t{" +(1259:4-1259:12) " context" --> (755:0-755:12) "\n\t\t\t\tcontext" +(1259:12-1259:31) "._currentRenderer =" --> (755:12-755:31) "._currentRenderer =" +(1259:31-1260:4) " null;\n " --> (755:31-756:0) " null;" +(1260:4-1260:12) " context" --> (756:0-756:12) "\n\t\t\t\tcontext" +(1260:12-1260:32) "._currentRenderer2 =" --> (756:12-756:32) "._currentRenderer2 =" +(1260:32-1261:3) " null;\n " --> (756:32-757:3) " null;\n\t\t" +(1261:3-1263:2) "}\n\n " --> (757:3-758:0) "\t}" +(1263:2-1263:9) " return" --> (758:0-758:10) "\n\t\t\treturn" +(1263:9-1264:1) " context;\n" --> (758:10-759:2) " context;\n\t" +(1264:1-1266:0) "}\n" --> (759:2-760:2) "\t}\n\t" +(1266:0-1266:4) "\nvar" --> (760:2-760:6) "\tvar" +(1266:4-1266:21) " Uninitialized = " --> (760:6-760:23) " Uninitialized = " +(1266:21-1267:0) "-1;" --> (760:23-761:2) "-1;\n\t" +(1267:0-1267:4) "\nvar" --> (761:2-761:6) "\tvar" +(1267:4-1267:14) " Pending =" --> (761:6-761:16) " Pending =" +(1267:14-1268:0) " 0;" --> (761:16-762:2) " 0;\n\t" +(1268:0-1268:4) "\nvar" --> (762:2-762:6) "\tvar" +(1268:4-1268:15) " Resolved =" --> (762:6-762:17) " Resolved =" +(1268:15-1269:0) " 1;" --> (762:17-763:2) " 1;\n\t" +(1269:0-1269:4) "\nvar" --> (763:2-763:6) "\tvar" +(1269:4-1269:15) " Rejected =" --> (763:6-763:17) " Rejected =" +(1269:15-1271:0) " 2;\n" --> (763:17-764:2) " 2;\n\t" +(1271:0-1271:9) "\nfunction" --> (764:2-764:11) "\tfunction" +(1271:9-1271:25) " lazyInitializer" --> (764:11-764:27) " lazyInitializer" +(1271:25-1271:34) "(payload)" --> (764:27-764:36) "(payload)" +(1271:34-1272:2) " {\n " --> (764:36-765:0) " {" +(1272:2-1272:6) " if " --> (765:0-765:7) "\n\t\t\tif " +(1272:6-1272:14) "(payload" --> (765:7-765:15) "(payload" +(1272:14-1272:26) "._status ===" --> (765:15-765:27) "._status ===" +(1272:26-1272:41) " Uninitialized)" --> (765:27-765:42) " Uninitialized)" +(1272:41-1273:4) " {\n " --> (765:42-766:4) " {\n\t\t\t" +(1273:4-1273:8) " var" --> (766:4-766:8) "\tvar" +(1273:8-1273:15) " ctor =" --> (766:8-766:15) " ctor =" +(1273:15-1273:23) " payload" --> (766:15-766:23) " payload" +(1273:23-1274:4) "._result;\n " --> (766:23-767:4) "._result;\n\t\t\t" +(1274:4-1274:8) " var" --> (767:4-767:8) "\tvar" +(1274:8-1274:19) " thenable =" --> (767:8-767:19) " thenable =" +(1274:19-1274:25) " ctor(" --> (767:19-767:25) " ctor(" +(1274:25-1276:4) "); // Transition to the next state.\n\n " --> (767:25-768:4) ");\n\t\t\t" +(1276:4-1276:8) " var" --> (768:4-768:8) "\tvar" +(1276:8-1276:18) " pending =" --> (768:8-768:18) " pending =" +(1276:18-1277:4) " payload;\n " --> (768:18-769:0) " payload;" +(1277:4-1277:12) " pending" --> (769:0-769:12) "\n\t\t\t\tpending" +(1277:12-1277:22) "._status =" --> (769:12-769:22) "._status =" +(1277:22-1278:4) " Pending;\n " --> (769:22-770:0) " Pending;" +(1278:4-1278:12) " pending" --> (770:0-770:12) "\n\t\t\t\tpending" +(1278:12-1278:22) "._result =" --> (770:12-770:22) "._result =" +(1278:22-1279:4) " thenable;\n " --> (770:22-771:0) " thenable;" +(1279:4-1279:13) " thenable" --> (771:0-771:13) "\n\t\t\t\tthenable" +(1279:13-1279:18) ".then" --> (771:13-771:18) ".then" +(1279:18-1279:28) "(function " --> (771:18-771:27) "(function" +(1279:28-1279:42) "(moduleObject)" --> (771:27-771:41) "(moduleObject)" +(1279:42-1280:6) " {\n " --> (771:41-772:0) " {" +(1280:6-1280:10) " if " --> (772:0-772:9) "\n\t\t\t\t\tif " +(1280:10-1280:18) "(payload" --> (772:9-772:17) "(payload" +(1280:18-1280:30) "._status ===" --> (772:17-772:29) "._status ===" +(1280:30-1280:39) " Pending)" --> (772:29-772:38) " Pending)" +(1280:39-1281:8) " {\n " --> (772:38-773:6) " {\n\t\t\t\t\t" +(1281:8-1281:12) " var" --> (773:6-773:10) "\tvar" +(1281:12-1281:28) " defaultExport =" --> (773:10-773:26) " defaultExport =" +(1281:28-1281:41) " moduleObject" --> (773:26-773:39) " moduleObject" +(1281:41-1283:8) ".default;\n\n " --> (773:39-774:6) ".default;\n\t\t\t\t\t" +(1283:8-1284:10) " {\n " --> (774:6-775:0) "\t{" +(1284:10-1284:14) " if " --> (775:0-775:11) "\n\t\t\t\t\t\t\tif " +(1284:14-1284:32) "(defaultExport ===" --> (775:11-775:29) "(defaultExport ===" +(1284:32-1284:43) " undefined)" --> (775:29-775:40) " undefined)" +(1284:43-1285:12) " {\n " --> (775:40-776:0) " {" +(1285:12-1285:18) " error" --> (776:0-776:14) "\n\t\t\t\t\t\t\t\terror" +(1285:18-1285:77) "('lazy: Expected the result of a dynamic import() call. ' +" --> (776:14-776:73) "(\"lazy: Expected the result of a dynamic import() call. \" +" +(1285:77-1286:12) " 'Instead received: %s\\n\\nYour code should look like: \\n ' + // Break up imports to avoid accidentally parsing them as dependencies.\n " --> (776:73-776:134) " \"Instead received: %s\\n\\nYour code should look like: \\n \" +" +(1286:12-1286:51) " 'const MyComponent = lazy(() => imp' +" --> (776:134-776:173) " \"const MyComponent = lazy(() => imp\" +" +(1286:51-1286:76) " \"ort('./MyComponent'))\"," --> (776:173-776:198) " \"ort('./MyComponent'))\"," +(1286:76-1286:89) " moduleObject" --> (776:198-776:211) " moduleObject" +(1286:89-1287:11) ");\n " --> (776:211-777:7) ");\n\t\t\t\t\t\t" +(1287:11-1288:9) "}\n " --> (777:7-778:6) "\t}\n\t\t\t\t\t" +(1288:9-1291:8) "} // Transition to the next state.\n\n\n " --> (778:6-779:6) "\t}\n\t\t\t\t\t" +(1291:8-1291:12) " var" --> (779:6-779:10) "\tvar" +(1291:12-1291:23) " resolved =" --> (779:10-779:21) " resolved =" +(1291:23-1292:8) " payload;\n " --> (779:21-780:0) " payload;" +(1292:8-1292:17) " resolved" --> (780:0-780:15) "\n\t\t\t\t\t\tresolved" +(1292:17-1292:27) "._status =" --> (780:15-780:25) "._status =" +(1292:27-1293:8) " Resolved;\n " --> (780:25-781:0) " Resolved;" +(1293:8-1293:17) " resolved" --> (781:0-781:15) "\n\t\t\t\t\t\tresolved" +(1293:17-1293:27) "._result =" --> (781:15-781:25) "._result =" +(1293:27-1294:7) " defaultExport;\n " --> (781:25-782:5) " defaultExport;\n\t\t\t\t" +(1294:7-1295:5) "}\n " --> (782:5-783:4) "\t}\n\t\t\t" +(1295:5-1295:7) "}," --> (783:4-783:7) "\t}," +(1295:7-1295:17) " function " --> (783:7-783:16) " function" +(1295:17-1295:24) "(error)" --> (783:16-783:23) "(error)" +(1295:24-1296:6) " {\n " --> (783:23-784:0) " {" +(1296:6-1296:10) " if " --> (784:0-784:9) "\n\t\t\t\t\tif " +(1296:10-1296:18) "(payload" --> (784:9-784:17) "(payload" +(1296:18-1296:30) "._status ===" --> (784:17-784:29) "._status ===" +(1296:30-1296:39) " Pending)" --> (784:29-784:38) " Pending)" +(1296:39-1298:8) " {\n // Transition to the next state.\n " --> (784:38-785:6) " {\n\t\t\t\t\t" +(1298:8-1298:12) " var" --> (785:6-785:10) "\tvar" +(1298:12-1298:23) " rejected =" --> (785:10-785:21) " rejected =" +(1298:23-1299:8) " payload;\n " --> (785:21-786:0) " payload;" +(1299:8-1299:17) " rejected" --> (786:0-786:15) "\n\t\t\t\t\t\trejected" +(1299:17-1299:27) "._status =" --> (786:15-786:25) "._status =" +(1299:27-1300:8) " Rejected;\n " --> (786:25-787:0) " Rejected;" +(1300:8-1300:17) " rejected" --> (787:0-787:15) "\n\t\t\t\t\t\trejected" +(1300:17-1300:27) "._result =" --> (787:15-787:25) "._result =" +(1300:27-1301:7) " error;\n " --> (787:25-788:5) " error;\n\t\t\t\t" +(1301:7-1302:5) "}\n " --> (788:5-789:4) "\t}\n\t\t\t" +(1302:5-1302:6) "}" --> (789:4-789:6) "\t}" +(1302:6-1303:3) ");\n " --> (789:6-790:3) ");\n\t\t" +(1303:3-1305:2) "}\n\n " --> (790:3-791:0) "\t}" +(1305:2-1305:6) " if " --> (791:0-791:7) "\n\t\t\tif " +(1305:6-1305:14) "(payload" --> (791:7-791:15) "(payload" +(1305:14-1305:26) "._status ===" --> (791:15-791:27) "._status ===" +(1305:26-1305:36) " Resolved)" --> (791:27-791:37) " Resolved)" +(1305:36-1306:4) " {\n " --> (791:37-792:0) " {" +(1306:4-1306:11) " return" --> (792:0-792:11) "\n\t\t\t\treturn" +(1306:11-1306:19) " payload" --> (792:11-792:19) " payload" +(1306:19-1307:3) "._result;\n " --> (792:19-793:3) "._result;\n\t\t" +(1307:3-1307:9) "} else" --> (793:3-793:10) "\t} else" +(1307:9-1308:4) " {\n " --> (793:10-794:0) " {" +(1308:4-1308:10) " throw" --> (794:0-794:10) "\n\t\t\t\tthrow" +(1308:10-1308:18) " payload" --> (794:10-794:18) " payload" +(1308:18-1309:3) "._result;\n " --> (794:18-795:3) "._result;\n\t\t" +(1309:3-1310:1) "}\n" --> (795:3-796:2) "\t}\n\t" +(1310:1-1312:0) "}\n" --> (796:2-797:2) "\t}\n\t" +(1312:0-1312:9) "\nfunction" --> (797:2-797:11) "\tfunction" +(1312:9-1312:14) " lazy" --> (797:11-797:16) " lazy" +(1312:14-1312:20) "(ctor)" --> (797:16-797:22) "(ctor)" +(1312:20-1313:2) " {\n " --> (797:22-798:3) " {\n\t\t" +(1313:2-1313:6) " var" --> (798:3-798:7) "\tvar" +(1313:6-1313:16) " payload =" --> (798:7-798:17) " payload =" +(1313:16-1315:4) " {\n // We use these fields to store the result.\n " --> (798:17-799:4) " {\n\t\t\t" +(1315:4-1315:14) " _status: " --> (799:4-799:14) "\t_status: " +(1315:14-1316:4) "-1,\n " --> (799:14-800:4) "-1,\n\t\t\t" +(1316:4-1316:13) " _result:" --> (800:4-800:13) "\t_result:" +(1316:13-1317:3) " ctor\n " --> (800:13-801:3) " ctor\n\t\t" +(1317:3-1318:2) "};\n " --> (801:3-802:3) "\t};\n\t\t" +(1318:2-1318:6) " var" --> (802:3-802:7) "\tvar" +(1318:6-1318:17) " lazyType =" --> (802:7-802:18) " lazyType =" +(1318:17-1319:4) " {\n " --> (802:18-803:4) " {\n\t\t\t" +(1319:4-1319:14) " $$typeof:" --> (803:4-803:14) "\t$$typeof:" +(1319:14-1320:4) " REACT_LAZY_TYPE,\n " --> (803:14-804:4) " REACT_LAZY_TYPE,\n\t\t\t" +(1320:4-1320:14) " _payload:" --> (804:4-804:14) "\t_payload:" +(1320:14-1321:4) " payload,\n " --> (804:14-805:4) " payload,\n\t\t\t" +(1321:4-1321:11) " _init:" --> (805:4-805:11) "\t_init:" +(1321:11-1322:3) " lazyInitializer\n " --> (805:11-806:3) " lazyInitializer\n\t\t" +(1322:3-1324:2) "};\n\n " --> (806:3-807:3) "\t};\n\t\t" +(1324:2-1326:4) " {\n // In production, this would just set it on the object.\n " --> (807:3-808:4) "\t{\n\t\t\t" +(1326:4-1326:8) " var" --> (808:4-808:8) "\tvar" +(1326:8-1327:4) " defaultProps;\n " --> (808:8-809:4) " defaultProps;\n\t\t\t" +(1327:4-1327:8) " var" --> (809:4-809:8) "\tvar" +(1327:8-1329:4) " propTypes; // $FlowFixMe\n\n " --> (809:8-810:0) " propTypes;" +(1329:4-1329:11) " Object" --> (810:0-810:11) "\n\t\t\t\tObject" +(1329:11-1329:28) ".defineProperties" --> (810:11-810:28) ".defineProperties" +(1329:28-1329:38) "(lazyType," --> (810:28-810:38) "(lazyType," +(1329:38-1330:6) " {\n " --> (810:38-811:5) " {\n\t\t\t\t" +(1330:6-1330:20) " defaultProps:" --> (811:5-811:19) "\tdefaultProps:" +(1330:20-1331:8) " {\n " --> (811:19-812:6) " {\n\t\t\t\t\t" +(1331:8-1331:22) " configurable:" --> (812:6-812:20) "\tconfigurable:" +(1331:22-1332:8) " true,\n " --> (812:20-813:6) " true,\n\t\t\t\t\t" +(1332:8-1332:13) " get:" --> (813:6-813:11) "\tget:" +(1332:13-1332:25) " function ()" --> (813:11-813:22) " function()" +(1332:25-1333:10) " {\n " --> (813:22-814:0) " {" +(1333:10-1333:17) " return" --> (814:0-814:14) "\n\t\t\t\t\t\t\treturn" +(1333:17-1334:9) " defaultProps;\n " --> (814:14-815:6) " defaultProps;\n\t\t\t\t\t" +(1334:9-1335:8) "},\n " --> (815:6-816:6) "\t},\n\t\t\t\t\t" +(1335:8-1335:13) " set:" --> (816:6-816:11) "\tset:" +(1335:13-1335:23) " function " --> (816:11-816:20) " function" +(1335:23-1335:40) "(newDefaultProps)" --> (816:20-816:37) "(newDefaultProps)" +(1335:40-1336:10) " {\n " --> (816:37-817:0) " {" +(1336:10-1336:16) " error" --> (817:0-817:13) "\n\t\t\t\t\t\t\terror" +(1336:16-1336:86) "('React.lazy(...): It is not supported to assign `defaultProps` to ' +" --> (817:13-817:83) "(\"React.lazy(...): It is not supported to assign `defaultProps` to \" +" +(1336:86-1336:156) " 'a lazy component import. Either specify them where the component ' +" --> (817:83-817:153) " \"a lazy component import. Either specify them where the component \" +" +(1336:156-1336:212) " 'is defined, or create a wrapping component around it.'" --> (817:153-817:209) " \"is defined, or create a wrapping component around it.\"" +(1336:212-1338:10) ");\n\n " --> (817:209-818:0) ");" +(1338:10-1338:25) " defaultProps =" --> (818:0-818:22) "\n\t\t\t\t\t\t\tdefaultProps =" +(1338:25-1341:10) " newDefaultProps; // Match production behavior more closely:\n // $FlowFixMe\n\n " --> (818:22-819:0) " newDefaultProps;" +(1341:10-1341:17) " Object" --> (819:0-819:14) "\n\t\t\t\t\t\t\tObject" +(1341:17-1341:32) ".defineProperty" --> (819:14-819:29) ".defineProperty" +(1341:32-1341:42) "(lazyType," --> (819:29-819:39) "(lazyType," +(1341:42-1341:58) " 'defaultProps'," --> (819:39-819:55) " \"defaultProps\"," +(1341:58-1342:12) " {\n " --> (819:55-820:8) " {\n\t\t\t\t\t\t\t" +(1342:12-1342:24) " enumerable:" --> (820:8-820:20) "\tenumerable:" +(1342:24-1343:11) " true\n " --> (820:20-821:7) " true\n\t\t\t\t\t\t" +(1343:11-1343:12) "}" --> (821:7-821:9) "\t}" +(1343:12-1344:9) ");\n " --> (821:9-822:6) ");\n\t\t\t\t\t" +(1344:9-1345:7) "}\n " --> (822:6-823:5) "\t}\n\t\t\t\t" +(1345:7-1346:6) "},\n " --> (823:5-824:5) "\t},\n\t\t\t\t" +(1346:6-1346:17) " propTypes:" --> (824:5-824:16) "\tpropTypes:" +(1346:17-1347:8) " {\n " --> (824:16-825:6) " {\n\t\t\t\t\t" +(1347:8-1347:22) " configurable:" --> (825:6-825:20) "\tconfigurable:" +(1347:22-1348:8) " true,\n " --> (825:20-826:6) " true,\n\t\t\t\t\t" +(1348:8-1348:13) " get:" --> (826:6-826:11) "\tget:" +(1348:13-1348:25) " function ()" --> (826:11-826:22) " function()" +(1348:25-1349:10) " {\n " --> (826:22-827:0) " {" +(1349:10-1349:17) " return" --> (827:0-827:14) "\n\t\t\t\t\t\t\treturn" +(1349:17-1350:9) " propTypes;\n " --> (827:14-828:6) " propTypes;\n\t\t\t\t\t" +(1350:9-1351:8) "},\n " --> (828:6-829:6) "\t},\n\t\t\t\t\t" +(1351:8-1351:13) " set:" --> (829:6-829:11) "\tset:" +(1351:13-1351:23) " function " --> (829:11-829:20) " function" +(1351:23-1351:37) "(newPropTypes)" --> (829:20-829:34) "(newPropTypes)" +(1351:37-1352:10) " {\n " --> (829:34-830:0) " {" +(1352:10-1352:16) " error" --> (830:0-830:13) "\n\t\t\t\t\t\t\terror" +(1352:16-1352:83) "('React.lazy(...): It is not supported to assign `propTypes` to ' +" --> (830:13-830:80) "(\"React.lazy(...): It is not supported to assign `propTypes` to \" +" +(1352:83-1352:153) " 'a lazy component import. Either specify them where the component ' +" --> (830:80-830:150) " \"a lazy component import. Either specify them where the component \" +" +(1352:153-1352:209) " 'is defined, or create a wrapping component around it.'" --> (830:150-830:206) " \"is defined, or create a wrapping component around it.\"" +(1352:209-1354:10) ");\n\n " --> (830:206-831:0) ");" +(1354:10-1354:22) " propTypes =" --> (831:0-831:19) "\n\t\t\t\t\t\t\tpropTypes =" +(1354:22-1357:10) " newPropTypes; // Match production behavior more closely:\n // $FlowFixMe\n\n " --> (831:19-832:0) " newPropTypes;" +(1357:10-1357:17) " Object" --> (832:0-832:14) "\n\t\t\t\t\t\t\tObject" +(1357:17-1357:32) ".defineProperty" --> (832:14-832:29) ".defineProperty" +(1357:32-1357:42) "(lazyType," --> (832:29-832:39) "(lazyType," +(1357:42-1357:55) " 'propTypes'," --> (832:39-832:52) " \"propTypes\"," +(1357:55-1358:12) " {\n " --> (832:52-833:8) " {\n\t\t\t\t\t\t\t" +(1358:12-1358:24) " enumerable:" --> (833:8-833:20) "\tenumerable:" +(1358:24-1359:11) " true\n " --> (833:20-834:7) " true\n\t\t\t\t\t\t" +(1359:11-1359:12) "}" --> (834:7-834:9) "\t}" +(1359:12-1360:9) ");\n " --> (834:9-835:6) ");\n\t\t\t\t\t" +(1360:9-1361:7) "}\n " --> (835:6-836:5) "\t}\n\t\t\t\t" +(1361:7-1362:5) "}\n " --> (836:5-837:4) "\t}\n\t\t\t" +(1362:5-1362:6) "}" --> (837:4-837:6) "\t}" +(1362:6-1363:3) ");\n " --> (837:6-838:3) ");\n\t\t" +(1363:3-1365:2) "}\n\n " --> (838:3-839:0) "\t}" +(1365:2-1365:9) " return" --> (839:0-839:10) "\n\t\t\treturn" +(1365:9-1366:1) " lazyType;\n" --> (839:10-840:2) " lazyType;\n\t" +(1366:1-1368:0) "}\n" --> (840:2-841:2) "\t}\n\t" +(1368:0-1368:9) "\nfunction" --> (841:2-841:11) "\tfunction" +(1368:9-1368:20) " forwardRef" --> (841:11-841:22) " forwardRef" +(1368:20-1368:28) "(render)" --> (841:22-841:30) "(render)" +(1368:28-1369:2) " {\n " --> (841:30-842:3) " {\n\t\t" +(1369:2-1370:4) " {\n " --> (842:3-843:0) "\t{" +(1370:4-1370:8) " if " --> (843:0-843:8) "\n\t\t\t\tif " +(1370:8-1370:18) "(render !=" --> (843:8-843:18) "(render !=" +(1370:18-1370:26) " null &&" --> (843:18-843:26) " null &&" +(1370:26-1370:33) " render" --> (843:26-843:33) " render" +(1370:33-1370:46) ".$$typeof ===" --> (843:33-843:46) ".$$typeof ===" +(1370:46-1370:63) " REACT_MEMO_TYPE)" --> (843:46-843:63) " REACT_MEMO_TYPE)" +(1370:63-1371:6) " {\n " --> (843:63-844:0) " {" +(1371:6-1371:12) " error" --> (844:0-844:11) "\n\t\t\t\t\terror" +(1371:12-1371:77) "('forwardRef requires a render function but received a `memo` ' +" --> (844:11-844:76) "(\"forwardRef requires a render function but received a `memo` \" +" +(1371:77-1371:131) " 'component. Instead of forwardRef(memo(...)), use ' +" --> (844:76-844:130) " \"component. Instead of forwardRef(memo(...)), use \" +" +(1371:131-1371:156) " 'memo(forwardRef(...)).'" --> (844:130-844:155) " \"memo(forwardRef(...)).\"" +(1371:156-1372:5) ");\n " --> (844:155-845:4) ");\n\t\t\t" +(1372:5-1372:22) "} else if (typeof" --> (845:4-845:22) "\t} else if (typeof" +(1372:22-1372:33) " render !==" --> (845:22-845:33) " render !==" +(1372:33-1372:45) " 'function')" --> (845:33-845:45) " \"function\")" +(1372:45-1373:6) " {\n " --> (845:45-846:0) " {" +(1373:6-1373:12) " error" --> (846:0-846:11) "\n\t\t\t\t\terror" +(1373:12-1373:71) "('forwardRef requires a render function but was given %s.'," --> (846:11-846:70) "(\"forwardRef requires a render function but was given %s.\"," +(1373:71-1373:82) " render ===" --> (846:70-846:81) " render ===" +(1373:82-1373:89) " null ?" --> (846:81-846:88) " null ?" +(1373:89-1373:105) " 'null' : typeof" --> (846:88-846:104) " \"null\" : typeof" +(1373:105-1373:112) " render" --> (846:104-846:111) " render" +(1373:112-1374:5) ");\n " --> (846:111-847:4) ");\n\t\t\t" +(1374:5-1374:11) "} else" --> (847:4-847:11) "\t} else" +(1374:11-1375:6) " {\n " --> (847:11-848:0) " {" +(1375:6-1375:10) " if " --> (848:0-848:9) "\n\t\t\t\t\tif " +(1375:10-1375:17) "(render" --> (848:9-848:16) "(render" +(1375:17-1375:28) ".length !==" --> (848:16-848:27) ".length !==" +(1375:28-1375:33) " 0 &&" --> (848:27-848:32) " 0 &&" +(1375:33-1375:40) " render" --> (848:32-848:39) " render" +(1375:40-1375:51) ".length !==" --> (848:39-848:50) ".length !==" +(1375:51-1375:54) " 2)" --> (848:50-848:53) " 2)" +(1375:54-1376:8) " {\n " --> (848:53-849:0) " {" +(1376:8-1376:14) " error" --> (849:0-849:12) "\n\t\t\t\t\t\terror" +(1376:14-1376:94) "('forwardRef render functions accept exactly two parameters: props and ref. %s'," --> (849:12-849:92) "(\"forwardRef render functions accept exactly two parameters: props and ref. %s\"," +(1376:94-1376:101) " render" --> (849:92-849:99) " render" +(1376:101-1376:112) ".length ===" --> (849:99-849:110) ".length ===" +(1376:112-1376:116) " 1 ?" --> (849:110-849:114) " 1 ?" +(1376:116-1376:161) " 'Did you forget to use the ref parameter?' :" --> (849:114-849:159) " \"Did you forget to use the ref parameter?\" :" +(1376:161-1376:207) " 'Any additional parameter will be undefined.'" --> (849:159-849:205) " \"Any additional parameter will be undefined.\"" +(1376:207-1377:7) ");\n " --> (849:205-850:5) ");\n\t\t\t\t" +(1377:7-1378:5) "}\n " --> (850:5-851:4) "\t}\n\t\t\t" +(1378:5-1380:4) "}\n\n " --> (851:4-852:0) "\t}" +(1380:4-1380:8) " if " --> (852:0-852:8) "\n\t\t\t\tif " +(1380:8-1380:18) "(render !=" --> (852:8-852:18) "(render !=" +(1380:18-1380:24) " null)" --> (852:18-852:24) " null)" +(1380:24-1381:6) " {\n " --> (852:24-853:0) " {" +(1381:6-1381:10) " if " --> (853:0-853:9) "\n\t\t\t\t\tif " +(1381:10-1381:17) "(render" --> (853:9-853:16) "(render" +(1381:17-1381:33) ".defaultProps !=" --> (853:16-853:32) ".defaultProps !=" +(1381:33-1381:41) " null ||" --> (853:32-853:40) " null ||" +(1381:41-1381:48) " render" --> (853:40-853:47) " render" +(1381:48-1381:61) ".propTypes !=" --> (853:47-853:60) ".propTypes !=" +(1381:61-1381:67) " null)" --> (853:60-853:66) " null)" +(1381:67-1382:8) " {\n " --> (853:66-854:0) " {" +(1382:8-1382:14) " error" --> (854:0-854:12) "\n\t\t\t\t\t\terror" +(1382:14-1382:89) "('forwardRef render functions do not support propTypes or defaultProps. ' +" --> (854:12-854:87) "(\"forwardRef render functions do not support propTypes or defaultProps. \" +" +(1382:89-1382:136) " 'Did you accidentally pass a React component?'" --> (854:87-854:134) " \"Did you accidentally pass a React component?\"" +(1382:136-1383:7) ");\n " --> (854:134-855:5) ");\n\t\t\t\t" +(1383:7-1384:5) "}\n " --> (855:5-856:4) "\t}\n\t\t\t" +(1384:5-1385:3) "}\n " --> (856:4-857:3) "\t}\n\t\t" +(1385:3-1387:2) "}\n\n " --> (857:3-858:3) "\t}\n\t\t" +(1387:2-1387:6) " var" --> (858:3-858:7) "\tvar" +(1387:6-1387:20) " elementType =" --> (858:7-858:21) " elementType =" +(1387:20-1388:4) " {\n " --> (858:21-859:4) " {\n\t\t\t" +(1388:4-1388:14) " $$typeof:" --> (859:4-859:14) "\t$$typeof:" +(1388:14-1389:12) " REACT_FORWARD_REF_TYPE,\n render:" --> (859:14-860:4) " REACT_FORWARD_REF_TYPE,\n\t\t\t" +(1389:12-1390:3) " render\n " --> (860:4-861:3) "\trender\n\t\t" +(1390:3-1392:2) "};\n\n " --> (861:3-862:3) "\t};\n\t\t" +(1392:2-1393:4) " {\n " --> (862:3-863:4) "\t{\n\t\t\t" +(1393:4-1393:8) " var" --> (863:4-863:8) "\tvar" +(1393:8-1394:4) " ownName;\n " --> (863:8-864:0) " ownName;" +(1394:4-1394:11) " Object" --> (864:0-864:11) "\n\t\t\t\tObject" +(1394:11-1394:26) ".defineProperty" --> (864:11-864:26) ".defineProperty" +(1394:26-1394:39) "(elementType," --> (864:26-864:39) "(elementType," +(1394:39-1394:54) " 'displayName'," --> (864:39-864:54) " \"displayName\"," +(1394:54-1395:6) " {\n " --> (864:54-865:5) " {\n\t\t\t\t" +(1395:6-1395:18) " enumerable:" --> (865:5-865:17) "\tenumerable:" +(1395:18-1396:6) " false,\n " --> (865:17-866:5) " false,\n\t\t\t\t" +(1396:6-1396:20) " configurable:" --> (866:5-866:19) "\tconfigurable:" +(1396:20-1397:6) " true,\n " --> (866:19-867:5) " true,\n\t\t\t\t" +(1397:6-1397:11) " get:" --> (867:5-867:10) "\tget:" +(1397:11-1397:23) " function ()" --> (867:10-867:21) " function()" +(1397:23-1398:8) " {\n " --> (867:21-868:0) " {" +(1398:8-1398:15) " return" --> (868:0-868:13) "\n\t\t\t\t\t\treturn" +(1398:15-1399:7) " ownName;\n " --> (868:13-869:5) " ownName;\n\t\t\t\t" +(1399:7-1400:6) "},\n " --> (869:5-870:5) "\t},\n\t\t\t\t" +(1400:6-1400:11) " set:" --> (870:5-870:10) "\tset:" +(1400:11-1400:21) " function " --> (870:10-870:19) " function" +(1400:21-1400:27) "(name)" --> (870:19-870:25) "(name)" +(1400:27-1401:8) " {\n " --> (870:25-871:0) " {" +(1401:8-1401:18) " ownName =" --> (871:0-871:16) "\n\t\t\t\t\t\townName =" +(1401:18-1403:8) " name;\n\n " --> (871:16-872:0) " name;" +(1403:8-1403:12) " if " --> (872:0-872:10) "\n\t\t\t\t\t\tif " +(1403:12-1403:19) "(render" --> (872:10-872:17) "(render" +(1403:19-1403:34) ".displayName ==" --> (872:17-872:32) ".displayName ==" +(1403:34-1403:40) " null)" --> (872:32-872:38) " null)" +(1403:40-1404:10) " {\n " --> (872:38-873:0) " {" +(1404:10-1404:17) " render" --> (873:0-873:14) "\n\t\t\t\t\t\t\trender" +(1404:17-1404:31) ".displayName =" --> (873:14-873:28) ".displayName =" +(1404:31-1405:9) " name;\n " --> (873:28-874:6) " name;\n\t\t\t\t\t" +(1405:9-1406:7) "}\n " --> (874:6-875:5) "\t}\n\t\t\t\t" +(1406:7-1407:5) "}\n " --> (875:5-876:4) "\t}\n\t\t\t" +(1407:5-1407:6) "}" --> (876:4-876:6) "\t}" +(1407:6-1408:3) ");\n " --> (876:6-877:3) ");\n\t\t" +(1408:3-1410:2) "}\n\n " --> (877:3-878:0) "\t}" +(1410:2-1410:9) " return" --> (878:0-878:10) "\n\t\t\treturn" +(1410:9-1411:1) " elementType;\n" --> (878:10-879:2) " elementType;\n\t" +(1411:1-1415:0) "}\n\n// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.\n" --> (879:2-880:2) "\t}\n\t" +(1415:0-1415:4) "\nvar" --> (880:2-880:6) "\tvar" +(1415:4-1415:21) " enableScopeAPI =" --> (880:6-880:23) " enableScopeAPI =" +(1415:21-1417:0) " false; // Experimental Create Event Handle API.\n" --> (880:23-881:2) " false;\n\t" +(1417:0-1417:9) "\nfunction" --> (881:2-881:11) "\tfunction" +(1417:9-1417:28) " isValidElementType" --> (881:11-881:30) " isValidElementType" +(1417:28-1417:34) "(type)" --> (881:30-881:36) "(type)" +(1417:34-1418:2) " {\n " --> (881:36-882:0) " {" +(1418:2-1418:13) " if (typeof" --> (882:0-882:14) "\n\t\t\tif (typeof" +(1418:13-1418:22) " type ===" --> (882:14-882:23) " type ===" +(1418:22-1418:41) " 'string' || typeof" --> (882:23-882:42) " \"string\" || typeof" +(1418:41-1418:50) " type ===" --> (882:42-882:51) " type ===" +(1418:50-1418:62) " 'function')" --> (882:51-882:63) " \"function\")" +(1418:62-1419:4) " {\n " --> (882:63-883:0) " {" +(1419:4-1419:11) " return" --> (883:0-883:11) "\n\t\t\t\treturn" +(1419:11-1420:3) " true;\n " --> (883:11-884:3) " true;\n\t\t" +(1420:3-1423:2) "} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).\n\n\n " --> (884:3-885:0) "\t}" +(1423:2-1423:6) " if " --> (885:0-885:7) "\n\t\t\tif " +(1423:6-1423:15) "(type ===" --> (885:7-885:16) "(type ===" +(1423:15-1423:23) " exports" --> (885:16-885:24) " exports" +(1423:23-1423:35) ".Fragment ||" --> (885:24-885:36) ".Fragment ||" +(1423:35-1423:44) " type ===" --> (885:36-885:45) " type ===" +(1423:44-1423:52) " exports" --> (885:45-885:53) " exports" +(1423:52-1423:64) ".Profiler ||" --> (885:53-885:65) ".Profiler ||" +(1423:64-1423:73) " type ===" --> (885:65-885:74) " type ===" +(1423:73-1423:106) " REACT_DEBUG_TRACING_MODE_TYPE ||" --> (885:74-885:107) " REACT_DEBUG_TRACING_MODE_TYPE ||" +(1423:106-1423:115) " type ===" --> (885:107-885:116) " type ===" +(1423:115-1423:123) " exports" --> (885:116-885:124) " exports" +(1423:123-1423:137) ".StrictMode ||" --> (885:124-885:138) ".StrictMode ||" +(1423:137-1423:146) " type ===" --> (885:138-885:147) " type ===" +(1423:146-1423:154) " exports" --> (885:147-885:155) " exports" +(1423:154-1423:166) ".Suspense ||" --> (885:155-885:167) ".Suspense ||" +(1423:166-1423:175) " type ===" --> (885:167-885:176) " type ===" +(1423:175-1423:203) " REACT_SUSPENSE_LIST_TYPE ||" --> (885:176-885:204) " REACT_SUSPENSE_LIST_TYPE ||" +(1423:203-1423:212) " type ===" --> (885:204-885:213) " type ===" +(1423:212-1423:240) " REACT_LEGACY_HIDDEN_TYPE ||" --> (885:213-885:241) " REACT_LEGACY_HIDDEN_TYPE ||" +(1423:240-1423:257) " enableScopeAPI )" --> (885:241-885:257) " enableScopeAPI)" +(1423:257-1424:4) " {\n " --> (885:257-886:0) " {" +(1424:4-1424:11) " return" --> (886:0-886:11) "\n\t\t\t\treturn" +(1424:11-1425:3) " true;\n " --> (886:11-887:3) " true;\n\t\t" +(1425:3-1427:2) "}\n\n " --> (887:3-888:0) "\t}" +(1427:2-1427:13) " if (typeof" --> (888:0-888:14) "\n\t\t\tif (typeof" +(1427:13-1427:22) " type ===" --> (888:14-888:23) " type ===" +(1427:22-1427:34) " 'object' &&" --> (888:23-888:35) " \"object\" &&" +(1427:34-1427:43) " type !==" --> (888:35-888:44) " type !==" +(1427:43-1427:49) " null)" --> (888:44-888:50) " null)" +(1427:49-1428:4) " {\n " --> (888:50-889:0) " {" +(1428:4-1428:8) " if " --> (889:0-889:8) "\n\t\t\t\tif " +(1428:8-1428:13) "(type" --> (889:8-889:13) "(type" +(1428:13-1428:26) ".$$typeof ===" --> (889:13-889:26) ".$$typeof ===" +(1428:26-1428:45) " REACT_LAZY_TYPE ||" --> (889:26-889:45) " REACT_LAZY_TYPE ||" +(1428:45-1428:50) " type" --> (889:45-889:50) " type" +(1428:50-1428:63) ".$$typeof ===" --> (889:50-889:63) ".$$typeof ===" +(1428:63-1428:82) " REACT_MEMO_TYPE ||" --> (889:63-889:82) " REACT_MEMO_TYPE ||" +(1428:82-1428:87) " type" --> (889:82-889:87) " type" +(1428:87-1428:100) ".$$typeof ===" --> (889:87-889:100) ".$$typeof ===" +(1428:100-1428:123) " REACT_PROVIDER_TYPE ||" --> (889:100-889:123) " REACT_PROVIDER_TYPE ||" +(1428:123-1428:128) " type" --> (889:123-889:128) " type" +(1428:128-1428:141) ".$$typeof ===" --> (889:128-889:141) ".$$typeof ===" +(1428:141-1428:163) " REACT_CONTEXT_TYPE ||" --> (889:141-889:163) " REACT_CONTEXT_TYPE ||" +(1428:163-1428:168) " type" --> (889:163-889:168) " type" +(1428:168-1428:181) ".$$typeof ===" --> (889:168-889:181) ".$$typeof ===" +(1428:181-1428:207) " REACT_FORWARD_REF_TYPE ||" --> (889:181-889:207) " REACT_FORWARD_REF_TYPE ||" +(1428:207-1428:212) " type" --> (889:207-889:212) " type" +(1428:212-1428:225) ".$$typeof ===" --> (889:212-889:225) ".$$typeof ===" +(1428:225-1428:251) " REACT_FUNDAMENTAL_TYPE ||" --> (889:225-889:251) " REACT_FUNDAMENTAL_TYPE ||" +(1428:251-1428:256) " type" --> (889:251-889:256) " type" +(1428:256-1428:269) ".$$typeof ===" --> (889:256-889:269) ".$$typeof ===" +(1428:269-1428:289) " REACT_BLOCK_TYPE ||" --> (889:269-889:289) " REACT_BLOCK_TYPE ||" +(1428:289-1428:294) " type" --> (889:289-889:294) " type" +(1428:294-1428:301) "[0] ===" --> (889:294-889:301) "[0] ===" +(1428:301-1428:326) " REACT_SERVER_BLOCK_TYPE)" --> (889:301-889:326) " REACT_SERVER_BLOCK_TYPE)" +(1428:326-1429:6) " {\n " --> (889:326-890:0) " {" +(1429:6-1429:13) " return" --> (890:0-890:12) "\n\t\t\t\t\treturn" +(1429:13-1430:5) " true;\n " --> (890:12-891:4) " true;\n\t\t\t" +(1430:5-1431:3) "}\n " --> (891:4-892:3) "\t}\n\t\t" +(1431:3-1433:2) "}\n\n " --> (892:3-893:0) "\t}" +(1433:2-1433:9) " return" --> (893:0-893:10) "\n\t\t\treturn" +(1433:9-1434:1) " false;\n" --> (893:10-894:2) " false;\n\t" +(1434:1-1436:0) "}\n" --> (894:2-895:2) "\t}\n\t" +(1436:0-1436:9) "\nfunction" --> (895:2-895:11) "\tfunction" +(1436:9-1436:14) " memo" --> (895:11-895:16) " memo" +(1436:14-1436:20) "(type," --> (895:16-895:22) "(type," +(1436:20-1436:29) " compare)" --> (895:22-895:31) " compare)" +(1436:29-1437:2) " {\n " --> (895:31-896:3) " {\n\t\t" +(1437:2-1438:4) " {\n " --> (896:3-897:0) "\t{" +(1438:4-1438:9) " if (" --> (897:0-897:9) "\n\t\t\t\tif (" +(1438:9-1438:28) "!isValidElementType" --> (897:9-897:28) "!isValidElementType" +(1438:28-1438:33) "(type" --> (897:28-897:33) "(type" +(1438:33-1438:35) "))" --> (897:33-897:35) "))" +(1438:35-1439:6) " {\n " --> (897:35-898:0) " {" +(1439:6-1439:12) " error" --> (898:0-898:11) "\n\t\t\t\t\terror" +(1439:12-1439:71) "('memo: The first argument must be a component. Instead ' +" --> (898:11-898:70) "(\"memo: The first argument must be a component. Instead \" +" +(1439:71-1439:87) " 'received: %s'," --> (898:70-898:86) " \"received: %s\"," +(1439:87-1439:96) " type ===" --> (898:86-898:95) " type ===" +(1439:96-1439:103) " null ?" --> (898:95-898:102) " null ?" +(1439:103-1439:119) " 'null' : typeof" --> (898:102-898:118) " \"null\" : typeof" +(1439:119-1439:124) " type" --> (898:118-898:123) " type" +(1439:124-1440:5) ");\n " --> (898:123-899:4) ");\n\t\t\t" +(1440:5-1441:3) "}\n " --> (899:4-900:3) "\t}\n\t\t" +(1441:3-1443:2) "}\n\n " --> (900:3-901:3) "\t}\n\t\t" +(1443:2-1443:6) " var" --> (901:3-901:7) "\tvar" +(1443:6-1443:20) " elementType =" --> (901:7-901:21) " elementType =" +(1443:20-1444:4) " {\n " --> (901:21-902:4) " {\n\t\t\t" +(1444:4-1444:14) " $$typeof:" --> (902:4-902:14) "\t$$typeof:" +(1444:14-1445:10) " REACT_MEMO_TYPE,\n type:" --> (902:14-903:4) " REACT_MEMO_TYPE,\n\t\t\t" +(1445:10-1446:4) " type,\n " --> (903:4-904:4) "\ttype,\n\t\t\t" +(1446:4-1446:13) " compare:" --> (904:4-904:13) "\tcompare:" +(1446:13-1446:25) " compare ===" --> (904:13-904:25) " compare ===" +(1446:25-1446:37) " undefined ?" --> (904:25-904:37) " undefined ?" +(1446:37-1446:44) " null :" --> (904:37-904:44) " null :" +(1446:44-1447:3) " compare\n " --> (904:44-905:3) " compare\n\t\t" +(1447:3-1449:2) "};\n\n " --> (905:3-906:3) "\t};\n\t\t" +(1449:2-1450:4) " {\n " --> (906:3-907:4) "\t{\n\t\t\t" +(1450:4-1450:8) " var" --> (907:4-907:8) "\tvar" +(1450:8-1451:4) " ownName;\n " --> (907:8-908:0) " ownName;" +(1451:4-1451:11) " Object" --> (908:0-908:11) "\n\t\t\t\tObject" +(1451:11-1451:26) ".defineProperty" --> (908:11-908:26) ".defineProperty" +(1451:26-1451:39) "(elementType," --> (908:26-908:39) "(elementType," +(1451:39-1451:54) " 'displayName'," --> (908:39-908:54) " \"displayName\"," +(1451:54-1452:6) " {\n " --> (908:54-909:5) " {\n\t\t\t\t" +(1452:6-1452:18) " enumerable:" --> (909:5-909:17) "\tenumerable:" +(1452:18-1453:6) " false,\n " --> (909:17-910:5) " false,\n\t\t\t\t" +(1453:6-1453:20) " configurable:" --> (910:5-910:19) "\tconfigurable:" +(1453:20-1454:6) " true,\n " --> (910:19-911:5) " true,\n\t\t\t\t" +(1454:6-1454:11) " get:" --> (911:5-911:10) "\tget:" +(1454:11-1454:23) " function ()" --> (911:10-911:21) " function()" +(1454:23-1455:8) " {\n " --> (911:21-912:0) " {" +(1455:8-1455:15) " return" --> (912:0-912:13) "\n\t\t\t\t\t\treturn" +(1455:15-1456:7) " ownName;\n " --> (912:13-913:5) " ownName;\n\t\t\t\t" +(1456:7-1457:6) "},\n " --> (913:5-914:5) "\t},\n\t\t\t\t" +(1457:6-1457:11) " set:" --> (914:5-914:10) "\tset:" +(1457:11-1457:21) " function " --> (914:10-914:19) " function" +(1457:21-1457:27) "(name)" --> (914:19-914:25) "(name)" +(1457:27-1458:8) " {\n " --> (914:25-915:0) " {" +(1458:8-1458:18) " ownName =" --> (915:0-915:16) "\n\t\t\t\t\t\townName =" +(1458:18-1460:8) " name;\n\n " --> (915:16-916:0) " name;" +(1460:8-1460:12) " if " --> (916:0-916:10) "\n\t\t\t\t\t\tif " +(1460:12-1460:17) "(type" --> (916:10-916:15) "(type" +(1460:17-1460:32) ".displayName ==" --> (916:15-916:30) ".displayName ==" +(1460:32-1460:38) " null)" --> (916:30-916:36) " null)" +(1460:38-1461:10) " {\n " --> (916:36-917:0) " {" +(1461:10-1461:15) " type" --> (917:0-917:12) "\n\t\t\t\t\t\t\ttype" +(1461:15-1461:29) ".displayName =" --> (917:12-917:26) ".displayName =" +(1461:29-1462:9) " name;\n " --> (917:26-918:6) " name;\n\t\t\t\t\t" +(1462:9-1463:7) "}\n " --> (918:6-919:5) "\t}\n\t\t\t\t" +(1463:7-1464:5) "}\n " --> (919:5-920:4) "\t}\n\t\t\t" +(1464:5-1464:6) "}" --> (920:4-920:6) "\t}" +(1464:6-1465:3) ");\n " --> (920:6-921:3) ");\n\t\t" +(1465:3-1467:2) "}\n\n " --> (921:3-922:0) "\t}" +(1467:2-1467:9) " return" --> (922:0-922:10) "\n\t\t\treturn" +(1467:9-1468:1) " elementType;\n" --> (922:10-923:2) " elementType;\n\t" +(1468:1-1470:0) "}\n" --> (923:2-924:2) "\t}\n\t" +(1470:0-1470:9) "\nfunction" --> (924:2-924:11) "\tfunction" +(1470:9-1470:29) " resolveDispatcher()" --> (924:11-924:31) " resolveDispatcher()" +(1470:29-1471:2) " {\n " --> (924:31-925:3) " {\n\t\t" +(1471:2-1471:6) " var" --> (925:3-925:7) "\tvar" +(1471:6-1471:19) " dispatcher =" --> (925:7-925:20) " dispatcher =" +(1471:19-1471:42) " ReactCurrentDispatcher" --> (925:20-925:43) " ReactCurrentDispatcher" +(1471:42-1473:2) ".current;\n\n " --> (925:43-926:0) ".current;" +(1473:2-1473:8) " if (!" --> (926:0-926:9) "\n\t\t\tif (!" +(1473:8-1473:23) "(dispatcher !==" --> (926:9-926:24) "(dispatcher !==" +(1473:23-1473:30) " null))" --> (926:24-926:31) " null))" +(1473:30-1474:4) " {\n " --> (926:31-927:4) " {\n\t\t\t" +(1474:4-1475:6) " {\n " --> (927:4-928:0) "\t{" +(1475:6-1475:12) " throw" --> (928:0-928:11) "\n\t\t\t\t\tthrow" +(1475:12-1475:19) " Error(" --> (928:11-928:17) " Error" +(1475:19-1475:454) " \"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.\" " --> (928:17-928:451) "(\"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.\"" +(1475:454-1476:5) ");\n " --> (928:451-929:4) ");\n\t\t\t" +(1476:5-1477:3) "}\n " --> (929:4-930:3) "\t}\n\t\t" +(1477:3-1479:2) "}\n\n " --> (930:3-931:0) "\t}" +(1479:2-1479:9) " return" --> (931:0-931:10) "\n\t\t\treturn" +(1479:9-1480:1) " dispatcher;\n" --> (931:10-932:2) " dispatcher;\n\t" +(1480:1-1482:0) "}\n" --> (932:2-933:2) "\t}\n\t" +(1482:0-1482:9) "\nfunction" --> (933:2-933:11) "\tfunction" +(1482:9-1482:20) " useContext" --> (933:11-933:22) " useContext" +(1482:20-1482:29) "(Context," --> (933:22-933:31) "(Context," +(1482:29-1482:52) " unstable_observedBits)" --> (933:31-933:54) " unstable_observedBits)" +(1482:52-1483:2) " {\n " --> (933:54-934:3) " {\n\t\t" +(1483:2-1483:6) " var" --> (934:3-934:7) "\tvar" +(1483:6-1483:19) " dispatcher =" --> (934:7-934:20) " dispatcher =" +(1483:19-1483:38) " resolveDispatcher(" --> (934:20-934:39) " resolveDispatcher(" +(1483:38-1485:2) ");\n\n " --> (934:39-935:3) ");\n\t\t" +(1485:2-1486:4) " {\n " --> (935:3-936:0) "\t{" +(1486:4-1486:8) " if " --> (936:0-936:8) "\n\t\t\t\tif " +(1486:8-1486:34) "(unstable_observedBits !==" --> (936:8-936:34) "(unstable_observedBits !==" +(1486:34-1486:45) " undefined)" --> (936:34-936:45) " undefined)" +(1486:45-1487:6) " {\n " --> (936:45-937:0) " {" +(1487:6-1487:12) " error" --> (937:0-937:11) "\n\t\t\t\t\terror" +(1487:12-1487:69) "('useContext() second argument is reserved for future ' +" --> (937:11-937:68) "(\"useContext() second argument is reserved for future \" +" +(1487:69-1487:117) " 'use in React. Passing it is not supported. ' +" --> (937:68-937:116) " \"use in React. Passing it is not supported. \" +" +(1487:117-1487:138) " 'You passed: %s.%s'," --> (937:116-937:137) " \"You passed: %s.%s\"," +(1487:138-1487:168) " unstable_observedBits, typeof" --> (937:137-937:167) " unstable_observedBits, typeof" +(1487:168-1487:194) " unstable_observedBits ===" --> (937:167-937:193) " unstable_observedBits ===" +(1487:194-1487:206) " 'number' &&" --> (937:193-937:205) " \"number\" &&" +(1487:206-1487:212) " Array" --> (937:205-937:211) " Array" +(1487:212-1487:220) ".isArray" --> (937:211-937:219) ".isArray" +(1487:220-1487:230) "(arguments" --> (937:219-937:229) "(arguments" +(1487:230-1487:233) "[2]" --> (937:229-937:232) "[2]" +(1487:233-1487:236) ") ?" --> (937:232-937:235) ") ?" +(1487:236-1487:281) " '\\n\\nDid you call array.map(useContext)? ' +" --> (937:235-937:280) " \"\\n\\nDid you call array.map(useContext)? \" +" +(1487:281-1487:332) " 'Calling Hooks inside a loop is not supported. ' +" --> (937:280-937:331) " \"Calling Hooks inside a loop is not supported. \" +" +(1487:332-1487:390) " 'Learn more at https://reactjs.org/link/rules-of-hooks' :" --> (937:331-937:389) " \"Learn more at https://reactjs.org/link/rules-of-hooks\" :" +(1487:390-1487:393) " ''" --> (937:389-937:392) " \"\"" +(1487:393-1488:5) ");\n " --> (937:392-938:4) ");\n\t\t\t" +(1488:5-1491:4) "} // TODO: add a more generic warning for invalid values.\n\n\n " --> (938:4-939:0) "\t}" +(1491:4-1491:8) " if " --> (939:0-939:8) "\n\t\t\t\tif " +(1491:8-1491:16) "(Context" --> (939:8-939:16) "(Context" +(1491:16-1491:29) "._context !==" --> (939:16-939:29) "._context !==" +(1491:29-1491:40) " undefined)" --> (939:29-939:40) " undefined)" +(1491:40-1492:6) " {\n " --> (939:40-940:5) " {\n\t\t\t\t" +(1492:6-1492:10) " var" --> (940:5-940:9) "\tvar" +(1492:10-1492:24) " realContext =" --> (940:9-940:23) " realContext =" +(1492:24-1492:32) " Context" --> (940:23-940:31) " Context" +(1492:32-1495:6) "._context; // Don't deduplicate because this legitimately causes bugs\n // and nobody should be using this in existing code.\n\n " --> (940:31-941:0) "._context;" +(1495:6-1495:10) " if " --> (941:0-941:9) "\n\t\t\t\t\tif " +(1495:10-1495:22) "(realContext" --> (941:9-941:21) "(realContext" +(1495:22-1495:35) ".Consumer ===" --> (941:21-941:34) ".Consumer ===" +(1495:35-1495:44) " Context)" --> (941:34-941:43) " Context)" +(1495:44-1496:8) " {\n " --> (941:43-942:0) " {" +(1496:8-1496:14) " error" --> (942:0-942:12) "\n\t\t\t\t\t\terror" +(1496:14-1496:102) "('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' +" --> (942:12-942:100) "(\"Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be \" +" +(1496:102-1496:189) " 'removed in a future major release. Did you mean to call useContext(Context) instead?'" --> (942:100-942:187) " \"removed in a future major release. Did you mean to call useContext(Context) instead?\"" +(1496:189-1497:7) ");\n " --> (942:187-943:5) ");\n\t\t\t\t" +(1497:7-1497:17) "} else if " --> (943:5-943:16) "\t} else if " +(1497:17-1497:29) "(realContext" --> (943:16-943:28) "(realContext" +(1497:29-1497:42) ".Provider ===" --> (943:28-943:41) ".Provider ===" +(1497:42-1497:51) " Context)" --> (943:41-943:50) " Context)" +(1497:51-1498:8) " {\n " --> (943:50-944:0) " {" +(1498:8-1498:14) " error" --> (944:0-944:12) "\n\t\t\t\t\t\terror" +(1498:14-1498:74) "('Calling useContext(Context.Provider) is not supported. ' +" --> (944:12-944:72) "(\"Calling useContext(Context.Provider) is not supported. \" +" +(1498:74-1498:126) " 'Did you mean to call useContext(Context) instead?'" --> (944:72-944:124) " \"Did you mean to call useContext(Context) instead?\"" +(1498:126-1499:7) ");\n " --> (944:124-945:5) ");\n\t\t\t\t" +(1499:7-1500:5) "}\n " --> (945:5-946:4) "\t}\n\t\t\t" +(1500:5-1501:3) "}\n " --> (946:4-947:3) "\t}\n\t\t" +(1501:3-1503:2) "}\n\n " --> (947:3-948:0) "\t}" +(1503:2-1503:9) " return" --> (948:0-948:10) "\n\t\t\treturn" +(1503:9-1503:20) " dispatcher" --> (948:10-948:21) " dispatcher" +(1503:20-1503:31) ".useContext" --> (948:21-948:32) ".useContext" +(1503:31-1503:40) "(Context," --> (948:32-948:41) "(Context," +(1503:40-1503:62) " unstable_observedBits" --> (948:41-948:63) " unstable_observedBits" +(1503:62-1504:1) ");\n" --> (948:63-949:2) ");\n\t" +(1504:1-1505:0) "}" --> (949:2-950:2) "\t}\n\t" +(1505:0-1505:9) "\nfunction" --> (950:2-950:11) "\tfunction" +(1505:9-1505:18) " useState" --> (950:11-950:20) " useState" +(1505:18-1505:32) "(initialState)" --> (950:20-950:34) "(initialState)" +(1505:32-1506:2) " {\n " --> (950:34-951:3) " {\n\t\t" +(1506:2-1506:6) " var" --> (951:3-951:7) "\tvar" +(1506:6-1506:19) " dispatcher =" --> (951:7-951:20) " dispatcher =" +(1506:19-1506:38) " resolveDispatcher(" --> (951:20-951:39) " resolveDispatcher(" +(1506:38-1507:2) ");\n " --> (951:39-952:0) ");" +(1507:2-1507:9) " return" --> (952:0-952:10) "\n\t\t\treturn" +(1507:9-1507:20) " dispatcher" --> (952:10-952:21) " dispatcher" +(1507:20-1507:29) ".useState" --> (952:21-952:30) ".useState" +(1507:29-1507:42) "(initialState" --> (952:30-952:43) "(initialState" +(1507:42-1508:1) ");\n" --> (952:43-953:2) ");\n\t" +(1508:1-1509:0) "}" --> (953:2-954:2) "\t}\n\t" +(1509:0-1509:9) "\nfunction" --> (954:2-954:11) "\tfunction" +(1509:9-1509:20) " useReducer" --> (954:11-954:22) " useReducer" +(1509:20-1509:29) "(reducer," --> (954:22-954:31) "(reducer," +(1509:29-1509:41) " initialArg," --> (954:31-954:43) " initialArg," +(1509:41-1509:47) " init)" --> (954:43-954:49) " init)" +(1509:47-1510:2) " {\n " --> (954:49-955:3) " {\n\t\t" +(1510:2-1510:6) " var" --> (955:3-955:7) "\tvar" +(1510:6-1510:19) " dispatcher =" --> (955:7-955:20) " dispatcher =" +(1510:19-1510:38) " resolveDispatcher(" --> (955:20-955:39) " resolveDispatcher(" +(1510:38-1511:2) ");\n " --> (955:39-956:0) ");" +(1511:2-1511:9) " return" --> (956:0-956:10) "\n\t\t\treturn" +(1511:9-1511:20) " dispatcher" --> (956:10-956:21) " dispatcher" +(1511:20-1511:31) ".useReducer" --> (956:21-956:32) ".useReducer" +(1511:31-1511:40) "(reducer," --> (956:32-956:41) "(reducer," +(1511:40-1511:52) " initialArg," --> (956:41-956:53) " initialArg," +(1511:52-1511:57) " init" --> (956:53-956:58) " init" +(1511:57-1512:1) ");\n" --> (956:58-957:2) ");\n\t" +(1512:1-1513:0) "}" --> (957:2-958:2) "\t}\n\t" +(1513:0-1513:9) "\nfunction" --> (958:2-958:11) "\tfunction" +(1513:9-1513:16) " useRef" --> (958:11-958:18) " useRef" +(1513:16-1513:30) "(initialValue)" --> (958:18-958:32) "(initialValue)" +(1513:30-1514:2) " {\n " --> (958:32-959:3) " {\n\t\t" +(1514:2-1514:6) " var" --> (959:3-959:7) "\tvar" +(1514:6-1514:19) " dispatcher =" --> (959:7-959:20) " dispatcher =" +(1514:19-1514:38) " resolveDispatcher(" --> (959:20-959:39) " resolveDispatcher(" +(1514:38-1515:2) ");\n " --> (959:39-960:0) ");" +(1515:2-1515:9) " return" --> (960:0-960:10) "\n\t\t\treturn" +(1515:9-1515:20) " dispatcher" --> (960:10-960:21) " dispatcher" +(1515:20-1515:27) ".useRef" --> (960:21-960:28) ".useRef" +(1515:27-1515:40) "(initialValue" --> (960:28-960:41) "(initialValue" +(1515:40-1516:1) ");\n" --> (960:41-961:2) ");\n\t" +(1516:1-1517:0) "}" --> (961:2-962:2) "\t}\n\t" +(1517:0-1517:9) "\nfunction" --> (962:2-962:11) "\tfunction" +(1517:9-1517:19) " useEffect" --> (962:11-962:21) " useEffect" +(1517:19-1517:27) "(create," --> (962:21-962:29) "(create," +(1517:27-1517:33) " deps)" --> (962:29-962:35) " deps)" +(1517:33-1518:2) " {\n " --> (962:35-963:3) " {\n\t\t" +(1518:2-1518:6) " var" --> (963:3-963:7) "\tvar" +(1518:6-1518:19) " dispatcher =" --> (963:7-963:20) " dispatcher =" +(1518:19-1518:38) " resolveDispatcher(" --> (963:20-963:39) " resolveDispatcher(" +(1518:38-1519:2) ");\n " --> (963:39-964:0) ");" +(1519:2-1519:9) " return" --> (964:0-964:10) "\n\t\t\treturn" +(1519:9-1519:20) " dispatcher" --> (964:10-964:21) " dispatcher" +(1519:20-1519:30) ".useEffect" --> (964:21-964:31) ".useEffect" +(1519:30-1519:38) "(create," --> (964:31-964:39) "(create," +(1519:38-1519:43) " deps" --> (964:39-964:44) " deps" +(1519:43-1520:1) ");\n" --> (964:44-965:2) ");\n\t" +(1520:1-1521:0) "}" --> (965:2-966:2) "\t}\n\t" +(1521:0-1521:9) "\nfunction" --> (966:2-966:11) "\tfunction" +(1521:9-1521:25) " useLayoutEffect" --> (966:11-966:27) " useLayoutEffect" +(1521:25-1521:33) "(create," --> (966:27-966:35) "(create," +(1521:33-1521:39) " deps)" --> (966:35-966:41) " deps)" +(1521:39-1522:2) " {\n " --> (966:41-967:3) " {\n\t\t" +(1522:2-1522:6) " var" --> (967:3-967:7) "\tvar" +(1522:6-1522:19) " dispatcher =" --> (967:7-967:20) " dispatcher =" +(1522:19-1522:38) " resolveDispatcher(" --> (967:20-967:39) " resolveDispatcher(" +(1522:38-1523:2) ");\n " --> (967:39-968:0) ");" +(1523:2-1523:9) " return" --> (968:0-968:10) "\n\t\t\treturn" +(1523:9-1523:20) " dispatcher" --> (968:10-968:21) " dispatcher" +(1523:20-1523:36) ".useLayoutEffect" --> (968:21-968:37) ".useLayoutEffect" +(1523:36-1523:44) "(create," --> (968:37-968:45) "(create," +(1523:44-1523:49) " deps" --> (968:45-968:50) " deps" +(1523:49-1524:1) ");\n" --> (968:50-969:2) ");\n\t" +(1524:1-1525:0) "}" --> (969:2-970:2) "\t}\n\t" +(1525:0-1525:9) "\nfunction" --> (970:2-970:11) "\tfunction" +(1525:9-1525:21) " useCallback" --> (970:11-970:23) " useCallback" +(1525:21-1525:31) "(callback," --> (970:23-970:33) "(callback," +(1525:31-1525:37) " deps)" --> (970:33-970:39) " deps)" +(1525:37-1526:2) " {\n " --> (970:39-971:3) " {\n\t\t" +(1526:2-1526:6) " var" --> (971:3-971:7) "\tvar" +(1526:6-1526:19) " dispatcher =" --> (971:7-971:20) " dispatcher =" +(1526:19-1526:38) " resolveDispatcher(" --> (971:20-971:39) " resolveDispatcher(" +(1526:38-1527:2) ");\n " --> (971:39-972:0) ");" +(1527:2-1527:9) " return" --> (972:0-972:10) "\n\t\t\treturn" +(1527:9-1527:20) " dispatcher" --> (972:10-972:21) " dispatcher" +(1527:20-1527:32) ".useCallback" --> (972:21-972:33) ".useCallback" +(1527:32-1527:42) "(callback," --> (972:33-972:43) "(callback," +(1527:42-1527:47) " deps" --> (972:43-972:48) " deps" +(1527:47-1528:1) ");\n" --> (972:48-973:2) ");\n\t" +(1528:1-1529:0) "}" --> (973:2-974:2) "\t}\n\t" +(1529:0-1529:9) "\nfunction" --> (974:2-974:11) "\tfunction" +(1529:9-1529:17) " useMemo" --> (974:11-974:19) " useMemo" +(1529:17-1529:25) "(create," --> (974:19-974:27) "(create," +(1529:25-1529:31) " deps)" --> (974:27-974:33) " deps)" +(1529:31-1530:2) " {\n " --> (974:33-975:3) " {\n\t\t" +(1530:2-1530:6) " var" --> (975:3-975:7) "\tvar" +(1530:6-1530:19) " dispatcher =" --> (975:7-975:20) " dispatcher =" +(1530:19-1530:38) " resolveDispatcher(" --> (975:20-975:39) " resolveDispatcher(" +(1530:38-1531:2) ");\n " --> (975:39-976:0) ");" +(1531:2-1531:9) " return" --> (976:0-976:10) "\n\t\t\treturn" +(1531:9-1531:20) " dispatcher" --> (976:10-976:21) " dispatcher" +(1531:20-1531:28) ".useMemo" --> (976:21-976:29) ".useMemo" +(1531:28-1531:36) "(create," --> (976:29-976:37) "(create," +(1531:36-1531:41) " deps" --> (976:37-976:42) " deps" +(1531:41-1532:1) ");\n" --> (976:42-977:2) ");\n\t" +(1532:1-1533:0) "}" --> (977:2-978:2) "\t}\n\t" +(1533:0-1533:9) "\nfunction" --> (978:2-978:11) "\tfunction" +(1533:9-1533:29) " useImperativeHandle" --> (978:11-978:31) " useImperativeHandle" +(1533:29-1533:34) "(ref," --> (978:31-978:36) "(ref," +(1533:34-1533:42) " create," --> (978:36-978:44) " create," +(1533:42-1533:48) " deps)" --> (978:44-978:50) " deps)" +(1533:48-1534:2) " {\n " --> (978:50-979:3) " {\n\t\t" +(1534:2-1534:6) " var" --> (979:3-979:7) "\tvar" +(1534:6-1534:19) " dispatcher =" --> (979:7-979:20) " dispatcher =" +(1534:19-1534:38) " resolveDispatcher(" --> (979:20-979:39) " resolveDispatcher(" +(1534:38-1535:2) ");\n " --> (979:39-980:0) ");" +(1535:2-1535:9) " return" --> (980:0-980:10) "\n\t\t\treturn" +(1535:9-1535:20) " dispatcher" --> (980:10-980:21) " dispatcher" +(1535:20-1535:40) ".useImperativeHandle" --> (980:21-980:41) ".useImperativeHandle" +(1535:40-1535:45) "(ref," --> (980:41-980:46) "(ref," +(1535:45-1535:53) " create," --> (980:46-980:54) " create," +(1535:53-1535:58) " deps" --> (980:54-980:59) " deps" +(1535:58-1536:1) ");\n" --> (980:59-981:2) ");\n\t" +(1536:1-1537:0) "}" --> (981:2-982:2) "\t}\n\t" +(1537:0-1537:9) "\nfunction" --> (982:2-982:11) "\tfunction" +(1537:9-1537:23) " useDebugValue" --> (982:11-982:25) " useDebugValue" +(1537:23-1537:30) "(value," --> (982:25-982:32) "(value," +(1537:30-1537:43) " formatterFn)" --> (982:32-982:45) " formatterFn)" +(1537:43-1538:2) " {\n " --> (982:45-983:3) " {\n\t\t" +(1538:2-1539:4) " {\n " --> (983:3-984:4) "\t{\n\t\t\t" +(1539:4-1539:8) " var" --> (984:4-984:8) "\tvar" +(1539:8-1539:21) " dispatcher =" --> (984:8-984:21) " dispatcher =" +(1539:21-1539:40) " resolveDispatcher(" --> (984:21-984:40) " resolveDispatcher(" +(1539:40-1540:4) ");\n " --> (984:40-985:0) ");" +(1540:4-1540:11) " return" --> (985:0-985:11) "\n\t\t\t\treturn" +(1540:11-1540:22) " dispatcher" --> (985:11-985:22) " dispatcher" +(1540:22-1540:36) ".useDebugValue" --> (985:22-985:36) ".useDebugValue" +(1540:36-1540:43) "(value," --> (985:36-985:43) "(value," +(1540:43-1540:55) " formatterFn" --> (985:43-985:55) " formatterFn" +(1540:55-1541:3) ");\n " --> (985:55-986:3) ");\n\t\t" +(1541:3-1542:1) "}\n" --> (986:3-987:2) "\t}\n\t" +(1542:1-1548:0) "}\n\n// Helpers to patch console.logs to avoid logging during side-effect free\n// replaying on render function. This currently only patches the object\n// lazily which won't cover if the log function was extracted eagerly.\n// We could also eagerly patch the method." --> (987:2-988:2) "\t}\n\t" +(1548:0-1548:4) "\nvar" --> (988:2-988:6) "\tvar" +(1548:4-1548:20) " disabledDepth =" --> (988:6-988:22) " disabledDepth =" +(1548:20-1549:0) " 0;" --> (988:22-989:2) " 0;\n\t" +(1549:0-1549:4) "\nvar" --> (989:2-989:6) "\tvar" +(1549:4-1550:0) " prevLog;" --> (989:6-990:2) " prevLog;\n\t" +(1550:0-1550:4) "\nvar" --> (990:2-990:6) "\tvar" +(1550:4-1551:0) " prevInfo;" --> (990:6-991:2) " prevInfo;\n\t" +(1551:0-1551:4) "\nvar" --> (991:2-991:6) "\tvar" +(1551:4-1552:0) " prevWarn;" --> (991:6-992:2) " prevWarn;\n\t" +(1552:0-1552:4) "\nvar" --> (992:2-992:6) "\tvar" +(1552:4-1553:0) " prevError;" --> (992:6-993:2) " prevError;\n\t" +(1553:0-1553:4) "\nvar" --> (993:2-993:6) "\tvar" +(1553:4-1554:0) " prevGroup;" --> (993:6-994:2) " prevGroup;\n\t" +(1554:0-1554:4) "\nvar" --> (994:2-994:6) "\tvar" +(1554:4-1555:0) " prevGroupCollapsed;" --> (994:6-995:2) " prevGroupCollapsed;\n\t" +(1555:0-1555:4) "\nvar" --> (995:2-995:6) "\tvar" +(1555:4-1557:0) " prevGroupEnd;\n" --> (995:6-996:2) " prevGroupEnd;\n\t" +(1557:0-1557:9) "\nfunction" --> (996:2-996:11) "\tfunction" +(1557:9-1557:23) " disabledLog()" --> (996:11-996:25) " disabledLog()" +(1557:23-1557:25) " {" --> (996:25-996:26) " " +(1557:25-1559:0) "}\n" --> (996:26-997:0) "{}" +(1559:0-1559:12) "\ndisabledLog" --> (997:0-997:14) "\n\t\tdisabledLog" +(1559:12-1559:33) ".__reactDisabledLog =" --> (997:14-997:35) ".__reactDisabledLog =" +(1559:33-1560:0) " true;" --> (997:35-998:2) " true;\n\t" +(1560:0-1560:9) "\nfunction" --> (998:2-998:11) "\tfunction" +(1560:9-1560:23) " disableLogs()" --> (998:11-998:25) " disableLogs()" +(1560:23-1561:2) " {\n " --> (998:25-999:3) " {\n\t\t" +(1561:2-1562:4) " {\n " --> (999:3-1000:0) "\t{" +(1562:4-1562:8) " if " --> (1000:0-1000:8) "\n\t\t\t\tif " +(1562:8-1562:26) "(disabledDepth ===" --> (1000:8-1000:26) "(disabledDepth ===" +(1562:26-1562:29) " 0)" --> (1000:26-1000:29) " 0)" +(1562:29-1564:6) " {\n /* eslint-disable react-internal/no-production-logging */\n " --> (1000:29-1001:0) " {" +(1564:6-1564:16) " prevLog =" --> (1001:0-1001:15) "\n\t\t\t\t\tprevLog =" +(1564:16-1564:24) " console" --> (1001:15-1001:23) " console" +(1564:24-1565:6) ".log;\n " --> (1001:23-1002:0) ".log;" +(1565:6-1565:17) " prevInfo =" --> (1002:0-1002:16) "\n\t\t\t\t\tprevInfo =" +(1565:17-1565:25) " console" --> (1002:16-1002:24) " console" +(1565:25-1566:6) ".info;\n " --> (1002:24-1003:0) ".info;" +(1566:6-1566:17) " prevWarn =" --> (1003:0-1003:16) "\n\t\t\t\t\tprevWarn =" +(1566:17-1566:25) " console" --> (1003:16-1003:24) " console" +(1566:25-1567:6) ".warn;\n " --> (1003:24-1004:0) ".warn;" +(1567:6-1567:18) " prevError =" --> (1004:0-1004:17) "\n\t\t\t\t\tprevError =" +(1567:18-1567:26) " console" --> (1004:17-1004:25) " console" +(1567:26-1568:6) ".error;\n " --> (1004:25-1005:0) ".error;" +(1568:6-1568:18) " prevGroup =" --> (1005:0-1005:17) "\n\t\t\t\t\tprevGroup =" +(1568:18-1568:26) " console" --> (1005:17-1005:25) " console" +(1568:26-1569:6) ".group;\n " --> (1005:25-1006:0) ".group;" +(1569:6-1569:27) " prevGroupCollapsed =" --> (1006:0-1006:26) "\n\t\t\t\t\tprevGroupCollapsed =" +(1569:27-1569:35) " console" --> (1006:26-1006:34) " console" +(1569:35-1570:6) ".groupCollapsed;\n " --> (1006:34-1007:0) ".groupCollapsed;" +(1570:6-1570:21) " prevGroupEnd =" --> (1007:0-1007:20) "\n\t\t\t\t\tprevGroupEnd =" +(1570:21-1570:29) " console" --> (1007:20-1007:28) " console" +(1570:29-1572:6) ".groupEnd; // https://github.com/facebook/react/issues/19099\n\n " --> (1007:28-1008:5) ".groupEnd;\n\t\t\t\t" +(1572:6-1572:10) " var" --> (1008:5-1008:9) "\tvar" +(1572:10-1572:18) " props =" --> (1008:9-1008:17) " props =" +(1572:18-1573:8) " {\n " --> (1008:17-1009:6) " {\n\t\t\t\t\t" +(1573:8-1573:22) " configurable:" --> (1009:6-1009:20) "\tconfigurable:" +(1573:22-1574:8) " true,\n " --> (1009:20-1010:6) " true,\n\t\t\t\t\t" +(1574:8-1574:20) " enumerable:" --> (1010:6-1010:18) "\tenumerable:" +(1574:20-1575:8) " true,\n " --> (1010:18-1011:6) " true,\n\t\t\t\t\t" +(1575:8-1575:15) " value:" --> (1011:6-1011:13) "\tvalue:" +(1575:15-1576:8) " disabledLog,\n " --> (1011:13-1012:6) " disabledLog,\n\t\t\t\t\t" +(1576:8-1576:18) " writable:" --> (1012:6-1012:16) "\twritable:" +(1576:18-1577:7) " true\n " --> (1012:16-1013:5) " true\n\t\t\t\t" +(1577:7-1579:6) "}; // $FlowFixMe Flow thinks console is immutable.\n\n " --> (1013:5-1014:0) "\t};" +(1579:6-1579:13) " Object" --> (1014:0-1014:12) "\n\t\t\t\t\tObject" +(1579:13-1579:30) ".defineProperties" --> (1014:12-1014:29) ".defineProperties" +(1579:30-1579:39) "(console," --> (1014:29-1014:38) "(console," +(1579:39-1580:8) " {\n " --> (1014:38-1015:6) " {\n\t\t\t\t\t" +(1580:8-1580:14) " info:" --> (1015:6-1015:12) "\tinfo:" +(1580:14-1581:8) " props,\n " --> (1015:12-1016:6) " props,\n\t\t\t\t\t" +(1581:8-1581:13) " log:" --> (1016:6-1016:11) "\tlog:" +(1581:13-1582:8) " props,\n " --> (1016:11-1017:6) " props,\n\t\t\t\t\t" +(1582:8-1582:14) " warn:" --> (1017:6-1017:12) "\twarn:" +(1582:14-1583:8) " props,\n " --> (1017:12-1018:6) " props,\n\t\t\t\t\t" +(1583:8-1583:15) " error:" --> (1018:6-1018:13) "\terror:" +(1583:15-1584:8) " props,\n " --> (1018:13-1019:6) " props,\n\t\t\t\t\t" +(1584:8-1584:15) " group:" --> (1019:6-1019:13) "\tgroup:" +(1584:15-1585:8) " props,\n " --> (1019:13-1020:6) " props,\n\t\t\t\t\t" +(1585:8-1585:24) " groupCollapsed:" --> (1020:6-1020:22) "\tgroupCollapsed:" +(1585:24-1586:8) " props,\n " --> (1020:22-1021:6) " props,\n\t\t\t\t\t" +(1586:8-1586:18) " groupEnd:" --> (1021:6-1021:16) "\tgroupEnd:" +(1586:18-1587:7) " props\n " --> (1021:16-1022:5) " props\n\t\t\t\t" +(1587:7-1587:8) "}" --> (1022:5-1022:7) "\t}" +(1587:8-1589:5) ");\n /* eslint-enable react-internal/no-production-logging */\n " --> (1022:7-1023:4) ");\n\t\t\t" +(1589:5-1591:4) "}\n\n " --> (1023:4-1024:0) "\t}" +(1591:4-1592:3) " disabledDepth++;\n " --> (1024:0-1025:3) "\n\t\t\t\tdisabledDepth++;\n\t\t" +(1592:3-1593:1) "}\n" --> (1025:3-1026:2) "\t}\n\t" +(1593:1-1594:0) "}" --> (1026:2-1027:2) "\t}\n\t" +(1594:0-1594:9) "\nfunction" --> (1027:2-1027:11) "\tfunction" +(1594:9-1594:24) " reenableLogs()" --> (1027:11-1027:26) " reenableLogs()" +(1594:24-1595:2) " {\n " --> (1027:26-1028:3) " {\n\t\t" +(1595:2-1596:4) " {\n " --> (1028:3-1029:0) "\t{" +(1596:4-1598:4) " disabledDepth--;\n\n " --> (1029:0-1030:0) "\n\t\t\t\tdisabledDepth--;" +(1598:4-1598:8) " if " --> (1030:0-1030:8) "\n\t\t\t\tif " +(1598:8-1598:26) "(disabledDepth ===" --> (1030:8-1030:26) "(disabledDepth ===" +(1598:26-1598:29) " 0)" --> (1030:26-1030:29) " 0)" +(1598:29-1600:6) " {\n /* eslint-disable react-internal/no-production-logging */\n " --> (1030:29-1031:5) " {\n\t\t\t\t" +(1600:6-1600:10) " var" --> (1031:5-1031:9) "\tvar" +(1600:10-1600:18) " props =" --> (1031:9-1031:17) " props =" +(1600:18-1601:8) " {\n " --> (1031:17-1032:6) " {\n\t\t\t\t\t" +(1601:8-1601:22) " configurable:" --> (1032:6-1032:20) "\tconfigurable:" +(1601:22-1602:8) " true,\n " --> (1032:20-1033:6) " true,\n\t\t\t\t\t" +(1602:8-1602:20) " enumerable:" --> (1033:6-1033:18) "\tenumerable:" +(1602:20-1603:8) " true,\n " --> (1033:18-1034:6) " true,\n\t\t\t\t\t" +(1603:8-1603:18) " writable:" --> (1034:6-1034:16) "\twritable:" +(1603:18-1604:7) " true\n " --> (1034:16-1035:5) " true\n\t\t\t\t" +(1604:7-1606:6) "}; // $FlowFixMe Flow thinks console is immutable.\n\n " --> (1035:5-1036:0) "\t};" +(1606:6-1606:13) " Object" --> (1036:0-1036:12) "\n\t\t\t\t\tObject" +(1606:13-1606:30) ".defineProperties" --> (1036:12-1036:29) ".defineProperties" +(1606:30-1606:39) "(console," --> (1036:29-1036:38) "(console," +(1606:39-1607:8) " {\n " --> (1036:38-1037:6) " {\n\t\t\t\t\t" +(1607:8-1607:13) " log:" --> (1037:6-1037:11) "\tlog:" +(1607:13-1607:21) " _assign" --> (1037:11-1037:19) " _assign" +(1607:21-1607:23) "({" --> (1037:19-1037:20) "(" +(1607:23-1607:25) "}," --> (1037:20-1037:23) "{}," +(1607:25-1607:32) " props," --> (1037:23-1037:30) " props," +(1607:32-1608:10) " {\n " --> (1037:30-1038:7) " {\n\t\t\t\t\t\t" +(1608:10-1608:17) " value:" --> (1038:7-1038:14) "\tvalue:" +(1608:17-1609:9) " prevLog\n " --> (1038:14-1039:6) " prevLog\n\t\t\t\t\t" +(1609:9-1609:10) "}" --> (1039:6-1039:8) "\t}" +(1609:10-1610:8) "),\n " --> (1039:8-1040:6) "),\n\t\t\t\t\t" +(1610:8-1610:14) " info:" --> (1040:6-1040:12) "\tinfo:" +(1610:14-1610:22) " _assign" --> (1040:12-1040:20) " _assign" +(1610:22-1610:24) "({" --> (1040:20-1040:21) "(" +(1610:24-1610:26) "}," --> (1040:21-1040:24) "{}," +(1610:26-1610:33) " props," --> (1040:24-1040:31) " props," +(1610:33-1611:10) " {\n " --> (1040:31-1041:7) " {\n\t\t\t\t\t\t" +(1611:10-1611:17) " value:" --> (1041:7-1041:14) "\tvalue:" +(1611:17-1612:9) " prevInfo\n " --> (1041:14-1042:6) " prevInfo\n\t\t\t\t\t" +(1612:9-1612:10) "}" --> (1042:6-1042:8) "\t}" +(1612:10-1613:8) "),\n " --> (1042:8-1043:6) "),\n\t\t\t\t\t" +(1613:8-1613:14) " warn:" --> (1043:6-1043:12) "\twarn:" +(1613:14-1613:22) " _assign" --> (1043:12-1043:20) " _assign" +(1613:22-1613:24) "({" --> (1043:20-1043:21) "(" +(1613:24-1613:26) "}," --> (1043:21-1043:24) "{}," +(1613:26-1613:33) " props," --> (1043:24-1043:31) " props," +(1613:33-1614:10) " {\n " --> (1043:31-1044:7) " {\n\t\t\t\t\t\t" +(1614:10-1614:17) " value:" --> (1044:7-1044:14) "\tvalue:" +(1614:17-1615:9) " prevWarn\n " --> (1044:14-1045:6) " prevWarn\n\t\t\t\t\t" +(1615:9-1615:10) "}" --> (1045:6-1045:8) "\t}" +(1615:10-1616:8) "),\n " --> (1045:8-1046:6) "),\n\t\t\t\t\t" +(1616:8-1616:15) " error:" --> (1046:6-1046:13) "\terror:" +(1616:15-1616:23) " _assign" --> (1046:13-1046:21) " _assign" +(1616:23-1616:25) "({" --> (1046:21-1046:22) "(" +(1616:25-1616:27) "}," --> (1046:22-1046:25) "{}," +(1616:27-1616:34) " props," --> (1046:25-1046:32) " props," +(1616:34-1617:10) " {\n " --> (1046:32-1047:7) " {\n\t\t\t\t\t\t" +(1617:10-1617:17) " value:" --> (1047:7-1047:14) "\tvalue:" +(1617:17-1618:9) " prevError\n " --> (1047:14-1048:6) " prevError\n\t\t\t\t\t" +(1618:9-1618:10) "}" --> (1048:6-1048:8) "\t}" +(1618:10-1619:8) "),\n " --> (1048:8-1049:6) "),\n\t\t\t\t\t" +(1619:8-1619:15) " group:" --> (1049:6-1049:13) "\tgroup:" +(1619:15-1619:23) " _assign" --> (1049:13-1049:21) " _assign" +(1619:23-1619:25) "({" --> (1049:21-1049:22) "(" +(1619:25-1619:27) "}," --> (1049:22-1049:25) "{}," +(1619:27-1619:34) " props," --> (1049:25-1049:32) " props," +(1619:34-1620:10) " {\n " --> (1049:32-1050:7) " {\n\t\t\t\t\t\t" +(1620:10-1620:17) " value:" --> (1050:7-1050:14) "\tvalue:" +(1620:17-1621:9) " prevGroup\n " --> (1050:14-1051:6) " prevGroup\n\t\t\t\t\t" +(1621:9-1621:10) "}" --> (1051:6-1051:8) "\t}" +(1621:10-1622:8) "),\n " --> (1051:8-1052:6) "),\n\t\t\t\t\t" +(1622:8-1622:24) " groupCollapsed:" --> (1052:6-1052:22) "\tgroupCollapsed:" +(1622:24-1622:32) " _assign" --> (1052:22-1052:30) " _assign" +(1622:32-1622:34) "({" --> (1052:30-1052:31) "(" +(1622:34-1622:36) "}," --> (1052:31-1052:34) "{}," +(1622:36-1622:43) " props," --> (1052:34-1052:41) " props," +(1622:43-1623:10) " {\n " --> (1052:41-1053:7) " {\n\t\t\t\t\t\t" +(1623:10-1623:17) " value:" --> (1053:7-1053:14) "\tvalue:" +(1623:17-1624:9) " prevGroupCollapsed\n " --> (1053:14-1054:6) " prevGroupCollapsed\n\t\t\t\t\t" +(1624:9-1624:10) "}" --> (1054:6-1054:8) "\t}" +(1624:10-1625:8) "),\n " --> (1054:8-1055:6) "),\n\t\t\t\t\t" +(1625:8-1625:18) " groupEnd:" --> (1055:6-1055:16) "\tgroupEnd:" +(1625:18-1625:26) " _assign" --> (1055:16-1055:24) " _assign" +(1625:26-1625:28) "({" --> (1055:24-1055:25) "(" +(1625:28-1625:30) "}," --> (1055:25-1055:28) "{}," +(1625:30-1625:37) " props," --> (1055:28-1055:35) " props," +(1625:37-1626:10) " {\n " --> (1055:35-1056:7) " {\n\t\t\t\t\t\t" +(1626:10-1626:17) " value:" --> (1056:7-1056:14) "\tvalue:" +(1626:17-1627:9) " prevGroupEnd\n " --> (1056:14-1057:6) " prevGroupEnd\n\t\t\t\t\t" +(1627:9-1627:10) "}" --> (1057:6-1057:8) "\t}" +(1627:10-1628:7) ")\n " --> (1057:8-1058:5) ")\n\t\t\t\t" +(1628:7-1628:8) "}" --> (1058:5-1058:7) "\t}" +(1628:8-1630:5) ");\n /* eslint-enable react-internal/no-production-logging */\n " --> (1058:7-1059:4) ");\n\t\t\t" +(1630:5-1632:4) "}\n\n " --> (1059:4-1060:0) "\t}" +(1632:4-1632:8) " if " --> (1060:0-1060:8) "\n\t\t\t\tif " +(1632:8-1632:24) "(disabledDepth <" --> (1060:8-1060:24) "(disabledDepth <" +(1632:24-1632:27) " 0)" --> (1060:24-1060:27) " 0)" +(1632:27-1633:6) " {\n " --> (1060:27-1061:0) " {" +(1633:6-1633:12) " error" --> (1061:0-1061:11) "\n\t\t\t\t\terror" +(1633:12-1633:48) "('disabledDepth fell below zero. ' +" --> (1061:11-1061:47) "(\"disabledDepth fell below zero. \" +" +(1633:48-1633:96) " 'This is a bug in React. Please file an issue.'" --> (1061:47-1061:95) " \"This is a bug in React. Please file an issue.\"" +(1633:96-1634:5) ");\n " --> (1061:95-1062:4) ");\n\t\t\t" +(1634:5-1635:3) "}\n " --> (1062:4-1063:3) "\t}\n\t\t" +(1635:3-1636:1) "}\n" --> (1063:3-1064:2) "\t}\n\t" +(1636:1-1638:0) "}\n" --> (1064:2-1065:2) "\t}\n\t" +(1638:0-1638:4) "\nvar" --> (1065:2-1065:6) "\tvar" +(1638:4-1638:31) " ReactCurrentDispatcher$1 =" --> (1065:6-1065:33) " ReactCurrentDispatcher$1 =" +(1638:31-1638:52) " ReactSharedInternals" --> (1065:33-1065:54) " ReactSharedInternals" +(1638:52-1639:0) ".ReactCurrentDispatcher;" --> (1065:54-1066:2) ".ReactCurrentDispatcher;\n\t" +(1639:0-1639:4) "\nvar" --> (1066:2-1066:6) "\tvar" +(1639:4-1640:0) " prefix;" --> (1066:6-1067:2) " prefix;\n\t" +(1640:0-1640:9) "\nfunction" --> (1067:2-1067:11) "\tfunction" +(1640:9-1640:39) " describeBuiltInComponentFrame" --> (1067:11-1067:41) " describeBuiltInComponentFrame" +(1640:39-1640:45) "(name," --> (1067:41-1067:47) "(name," +(1640:45-1640:53) " source," --> (1067:47-1067:55) " source," +(1640:53-1640:62) " ownerFn)" --> (1067:55-1067:64) " ownerFn)" +(1640:62-1641:2) " {\n " --> (1067:64-1068:3) " {\n\t\t" +(1641:2-1642:4) " {\n " --> (1068:3-1069:0) "\t{" +(1642:4-1642:8) " if " --> (1069:0-1069:8) "\n\t\t\t\tif " +(1642:8-1642:19) "(prefix ===" --> (1069:8-1069:19) "(prefix ===" +(1642:19-1642:30) " undefined)" --> (1069:19-1069:30) " undefined)" +(1642:30-1644:6) " {\n // Extract the VM specific prefix used by each line.\n " --> (1069:30-1070:0) " {" +(1644:6-1644:10) " try" --> (1070:0-1070:9) "\n\t\t\t\t\ttry" +(1644:10-1645:8) " {\n " --> (1070:9-1071:0) " {" +(1645:8-1645:14) " throw" --> (1071:0-1071:12) "\n\t\t\t\t\t\tthrow" +(1645:14-1645:21) " Error(" --> (1071:12-1071:19) " Error(" +(1645:21-1646:7) ");\n " --> (1071:19-1072:5) ");\n\t\t\t\t" +(1646:7-1646:15) "} catch " --> (1072:5-1072:14) "\t} catch " +(1646:15-1646:18) "(x)" --> (1072:14-1072:17) "(x)" +(1646:18-1647:8) " {\n " --> (1072:17-1073:6) " {\n\t\t\t\t\t" +(1647:8-1647:12) " var" --> (1073:6-1073:10) "\tvar" +(1647:12-1647:20) " match =" --> (1073:10-1073:18) " match =" +(1647:20-1647:22) " x" --> (1073:18-1073:20) " x" +(1647:22-1647:28) ".stack" --> (1073:20-1073:26) ".stack" +(1647:28-1647:34) ".trim(" --> (1073:26-1073:32) ".trim(" +(1647:34-1647:35) ")" --> (1073:32-1073:33) ")" +(1647:35-1647:41) ".match" --> (1073:33-1073:39) ".match" +(1647:41-1647:56) "(/\\n( *(at )?)/" --> (1073:39-1073:54) "(/\\n( *(at )?)/" +(1647:56-1648:8) ");\n " --> (1073:54-1074:0) ");" +(1648:8-1648:17) " prefix =" --> (1074:0-1074:15) "\n\t\t\t\t\t\tprefix =" +(1648:17-1648:26) " match &&" --> (1074:15-1074:24) " match &&" +(1648:26-1648:32) " match" --> (1074:24-1074:30) " match" +(1648:32-1648:38) "[1] ||" --> (1074:30-1074:36) "[1] ||" +(1648:38-1649:7) " '';\n " --> (1074:36-1075:5) " \"\";\n\t\t\t\t" +(1649:7-1650:5) "}\n " --> (1075:5-1076:4) "\t}\n\t\t\t" +(1650:5-1653:4) "} // We use the prefix to ensure our stacks line up with native stack frames.\n\n\n " --> (1076:4-1077:0) "\t}" +(1653:4-1653:11) " return" --> (1077:0-1077:11) "\n\t\t\t\treturn" +(1653:11-1653:18) " '\\n' +" --> (1077:11-1077:18) " \"\\n\" +" +(1653:18-1653:27) " prefix +" --> (1077:18-1077:27) " prefix +" +(1653:27-1654:3) " name;\n " --> (1077:27-1078:3) " name;\n\t\t" +(1654:3-1655:1) "}\n" --> (1078:3-1079:2) "\t}\n\t" +(1655:1-1656:0) "}" --> (1079:2-1080:2) "\t}\n\t" +(1656:0-1656:4) "\nvar" --> (1080:2-1080:6) "\tvar" +(1656:4-1656:14) " reentry =" --> (1080:6-1080:16) " reentry =" +(1656:14-1657:0) " false;" --> (1080:16-1081:2) " false;\n\t" +(1657:0-1657:4) "\nvar" --> (1081:2-1081:6) "\tvar" +(1657:4-1659:0) " componentFrameCache;\n" --> (1081:6-1082:2) " componentFrameCache;\n\t" +(1659:0-1660:2) "\n{\n " --> (1082:2-1083:3) "\t{\n\t\t" +(1660:2-1660:6) " var" --> (1083:3-1083:7) "\tvar" +(1660:6-1660:31) " PossiblyWeakMap = typeof" --> (1083:7-1083:32) " PossiblyWeakMap = typeof" +(1660:31-1660:43) " WeakMap ===" --> (1083:32-1083:44) " WeakMap ===" +(1660:43-1660:56) " 'function' ?" --> (1083:44-1083:57) " \"function\" ?" +(1660:56-1660:66) " WeakMap :" --> (1083:57-1083:67) " WeakMap :" +(1660:66-1661:2) " Map;\n " --> (1083:67-1084:0) " Map;" +(1661:2-1661:24) " componentFrameCache =" --> (1084:0-1084:25) "\n\t\t\tcomponentFrameCache =" +(1661:24-1661:28) " new" --> (1084:25-1084:29) " new" +(1661:28-1662:1) " PossiblyWeakMap();\n" --> (1084:29-1085:2) " PossiblyWeakMap();\n\t" +(1662:1-1664:0) "}\n" --> (1085:2-1086:2) "\t}\n\t" +(1664:0-1664:9) "\nfunction" --> (1086:2-1086:11) "\tfunction" +(1664:9-1664:38) " describeNativeComponentFrame" --> (1086:11-1086:40) " describeNativeComponentFrame" +(1664:38-1664:42) "(fn," --> (1086:40-1086:44) "(fn," +(1664:42-1664:53) " construct)" --> (1086:44-1086:55) " construct)" +(1664:53-1666:2) " {\n // If something asked for a stack inside a fake render, it should get ignored.\n " --> (1086:55-1087:0) " {" +(1666:2-1666:7) " if (" --> (1087:0-1087:8) "\n\t\t\tif (" +(1666:7-1666:13) "!fn ||" --> (1087:8-1087:14) "!fn ||" +(1666:13-1666:22) " reentry)" --> (1087:14-1087:23) " reentry)" +(1666:22-1667:4) " {\n " --> (1087:23-1088:0) " {" +(1667:4-1667:11) " return" --> (1088:0-1088:11) "\n\t\t\t\treturn" +(1667:11-1668:3) " '';\n " --> (1088:11-1089:3) " \"\";\n\t\t" +(1668:3-1670:2) "}\n\n " --> (1089:3-1090:3) "\t}\n\t\t" +(1670:2-1671:4) " {\n " --> (1090:3-1091:4) "\t{\n\t\t\t" +(1671:4-1671:8) " var" --> (1091:4-1091:8) "\tvar" +(1671:8-1671:16) " frame =" --> (1091:8-1091:16) " frame =" +(1671:16-1671:36) " componentFrameCache" --> (1091:16-1091:36) " componentFrameCache" +(1671:36-1671:40) ".get" --> (1091:36-1091:40) ".get" +(1671:40-1671:43) "(fn" --> (1091:40-1091:43) "(fn" +(1671:43-1673:4) ");\n\n " --> (1091:43-1092:0) ");" +(1673:4-1673:8) " if " --> (1092:0-1092:8) "\n\t\t\t\tif " +(1673:8-1673:18) "(frame !==" --> (1092:8-1092:18) "(frame !==" +(1673:18-1673:29) " undefined)" --> (1092:18-1092:29) " undefined)" +(1673:29-1674:6) " {\n " --> (1092:29-1093:0) " {" +(1674:6-1674:13) " return" --> (1093:0-1093:12) "\n\t\t\t\t\treturn" +(1674:13-1675:5) " frame;\n " --> (1093:12-1094:4) " frame;\n\t\t\t" +(1675:5-1676:3) "}\n " --> (1094:4-1095:3) "\t}\n\t\t" +(1676:3-1678:2) "}\n\n " --> (1095:3-1096:3) "\t}\n\t\t" +(1678:2-1678:6) " var" --> (1096:3-1096:7) "\tvar" +(1678:6-1679:2) " control;\n " --> (1096:7-1097:0) " control;" +(1679:2-1679:12) " reentry =" --> (1097:0-1097:13) "\n\t\t\treentry =" +(1679:12-1680:2) " true;\n " --> (1097:13-1098:3) " true;\n\t\t" +(1680:2-1680:6) " var" --> (1098:3-1098:7) "\tvar" +(1680:6-1680:34) " previousPrepareStackTrace =" --> (1098:7-1098:35) " previousPrepareStackTrace =" +(1680:34-1680:40) " Error" --> (1098:35-1098:41) " Error" +(1680:40-1682:2) ".prepareStackTrace; // $FlowFixMe It does accept undefined.\n\n " --> (1098:41-1099:0) ".prepareStackTrace;" +(1682:2-1682:8) " Error" --> (1099:0-1099:9) "\n\t\t\tError" +(1682:8-1682:28) ".prepareStackTrace =" --> (1099:9-1099:29) ".prepareStackTrace =" +(1682:28-1683:2) " undefined;\n " --> (1099:29-1100:3) " undefined;\n\t\t" +(1683:2-1683:6) " var" --> (1100:3-1100:7) "\tvar" +(1683:6-1685:2) " previousDispatcher;\n\n " --> (1100:7-1101:3) " previousDispatcher;\n\t\t" +(1685:2-1686:4) " {\n " --> (1101:3-1102:0) "\t{" +(1686:4-1686:25) " previousDispatcher =" --> (1102:0-1102:25) "\n\t\t\t\tpreviousDispatcher =" +(1686:25-1686:50) " ReactCurrentDispatcher$1" --> (1102:25-1102:50) " ReactCurrentDispatcher$1" +(1686:50-1689:4) ".current; // Set the dispatcher in DEV because this might be call in the render function\n // for warnings.\n\n " --> (1102:50-1103:0) ".current;" +(1689:4-1689:29) " ReactCurrentDispatcher$1" --> (1103:0-1103:29) "\n\t\t\t\tReactCurrentDispatcher$1" +(1689:29-1689:39) ".current =" --> (1103:29-1103:39) ".current =" +(1689:39-1690:4) " null;\n " --> (1103:39-1104:0) " null;" +(1690:4-1690:17) " disableLogs(" --> (1104:0-1104:17) "\n\t\t\t\tdisableLogs(" +(1690:17-1691:3) ");\n " --> (1104:17-1105:3) ");\n\t\t" +(1691:3-1693:2) "}\n\n " --> (1105:3-1106:0) "\t}" +(1693:2-1693:6) " try" --> (1106:0-1106:7) "\n\t\t\ttry" +(1693:6-1695:4) " {\n // This should throw.\n " --> (1106:7-1107:0) " {" +(1695:4-1695:8) " if " --> (1107:0-1107:8) "\n\t\t\t\tif " +(1695:8-1695:19) "(construct)" --> (1107:8-1107:19) "(construct)" +(1695:19-1697:6) " {\n // Something should be setting the props in the constructor.\n " --> (1107:19-1108:5) " {\n\t\t\t\t" +(1697:6-1697:10) " var" --> (1108:5-1108:9) "\tvar" +(1697:10-1697:17) " Fake =" --> (1108:9-1108:16) " Fake =" +(1697:17-1697:29) " function ()" --> (1108:16-1108:27) " function()" +(1697:29-1698:8) " {\n " --> (1108:27-1109:0) " {" +(1698:8-1698:14) " throw" --> (1109:0-1109:12) "\n\t\t\t\t\t\tthrow" +(1698:14-1698:21) " Error(" --> (1109:12-1109:19) " Error(" +(1698:21-1699:7) ");\n " --> (1109:19-1110:5) ");\n\t\t\t\t" +(1699:7-1702:6) "}; // $FlowFixMe\n\n\n " --> (1110:5-1111:0) "\t};" +(1702:6-1702:13) " Object" --> (1111:0-1111:12) "\n\t\t\t\t\tObject" +(1702:13-1702:28) ".defineProperty" --> (1111:12-1111:27) ".defineProperty" +(1702:28-1702:33) "(Fake" --> (1111:27-1111:32) "(Fake" +(1702:33-1702:44) ".prototype," --> (1111:32-1111:43) ".prototype," +(1702:44-1702:53) " 'props'," --> (1111:43-1111:52) " \"props\"," +(1702:53-1703:8) " {\n " --> (1111:52-1112:6) " {\n\t\t\t\t\t" +(1703:8-1703:13) " set:" --> (1112:6-1112:11) "\tset:" +(1703:13-1703:25) " function ()" --> (1112:11-1112:22) " function()" +(1703:25-1706:10) " {\n // We use a throwing setter instead of frozen or non-writable props\n // because that won't throw in a non-strict mode function.\n " --> (1112:22-1113:0) " {" +(1706:10-1706:16) " throw" --> (1113:0-1113:13) "\n\t\t\t\t\t\t\tthrow" +(1706:16-1706:23) " Error(" --> (1113:13-1113:20) " Error(" +(1706:23-1707:9) ");\n " --> (1113:20-1114:6) ");\n\t\t\t\t\t" +(1707:9-1708:7) "}\n " --> (1114:6-1115:5) "\t}\n\t\t\t\t" +(1708:7-1708:8) "}" --> (1115:5-1115:7) "\t}" +(1708:8-1710:6) ");\n\n " --> (1115:7-1116:0) ");" +(1710:6-1710:17) " if (typeof" --> (1116:0-1116:16) "\n\t\t\t\t\tif (typeof" +(1710:17-1710:29) " Reflect ===" --> (1116:16-1116:28) " Reflect ===" +(1710:29-1710:41) " 'object' &&" --> (1116:28-1116:40) " \"object\" &&" +(1710:41-1710:49) " Reflect" --> (1116:40-1116:48) " Reflect" +(1710:49-1710:60) ".construct)" --> (1116:48-1116:59) ".construct)" +(1710:60-1713:8) " {\n // We construct a different control for this case to include any extra\n // frames added by the construct call.\n " --> (1116:59-1117:0) " {" +(1713:8-1713:12) " try" --> (1117:0-1117:10) "\n\t\t\t\t\t\ttry" +(1713:12-1714:10) " {\n " --> (1117:10-1118:0) " {" +(1714:10-1714:18) " Reflect" --> (1118:0-1118:15) "\n\t\t\t\t\t\t\tReflect" +(1714:18-1714:28) ".construct" --> (1118:15-1118:25) ".construct" +(1714:28-1714:34) "(Fake," --> (1118:25-1118:31) "(Fake," +(1714:34-1714:36) " [" --> (1118:31-1118:33) " [" +(1714:36-1714:37) "]" --> (1118:33-1118:34) "]" +(1714:37-1715:9) ");\n " --> (1118:34-1119:6) ");\n\t\t\t\t\t" +(1715:9-1715:17) "} catch " --> (1119:6-1119:15) "\t} catch " +(1715:17-1715:20) "(x)" --> (1119:15-1119:18) "(x)" +(1715:20-1716:10) " {\n " --> (1119:18-1120:0) " {" +(1716:10-1716:20) " control =" --> (1120:0-1120:17) "\n\t\t\t\t\t\t\tcontrol =" +(1716:20-1717:9) " x;\n " --> (1120:17-1121:6) " x;\n\t\t\t\t\t" +(1717:9-1719:8) "}\n\n " --> (1121:6-1122:0) "\t}" +(1719:8-1719:16) " Reflect" --> (1122:0-1122:14) "\n\t\t\t\t\t\tReflect" +(1719:16-1719:26) ".construct" --> (1122:14-1122:24) ".construct" +(1719:26-1719:30) "(fn," --> (1122:24-1122:28) "(fn," +(1719:30-1719:32) " [" --> (1122:28-1122:30) " [" +(1719:32-1719:34) "]," --> (1122:30-1122:32) "]," +(1719:34-1719:39) " Fake" --> (1122:32-1122:37) " Fake" +(1719:39-1720:7) ");\n " --> (1122:37-1123:5) ");\n\t\t\t\t" +(1720:7-1720:13) "} else" --> (1123:5-1123:12) "\t} else" +(1720:13-1721:8) " {\n " --> (1123:12-1124:0) " {" +(1721:8-1721:12) " try" --> (1124:0-1124:10) "\n\t\t\t\t\t\ttry" +(1721:12-1722:10) " {\n " --> (1124:10-1125:0) " {" +(1722:10-1722:15) " Fake" --> (1125:0-1125:12) "\n\t\t\t\t\t\t\tFake" +(1722:15-1722:21) ".call(" --> (1125:12-1125:18) ".call(" +(1722:21-1723:9) ");\n " --> (1125:18-1126:6) ");\n\t\t\t\t\t" +(1723:9-1723:17) "} catch " --> (1126:6-1126:15) "\t} catch " +(1723:17-1723:20) "(x)" --> (1126:15-1126:18) "(x)" +(1723:20-1724:10) " {\n " --> (1126:18-1127:0) " {" +(1724:10-1724:20) " control =" --> (1127:0-1127:17) "\n\t\t\t\t\t\t\tcontrol =" +(1724:20-1725:9) " x;\n " --> (1127:17-1128:6) " x;\n\t\t\t\t\t" +(1725:9-1727:8) "}\n\n " --> (1128:6-1129:0) "\t}" +(1727:8-1727:11) " fn" --> (1129:0-1129:9) "\n\t\t\t\t\t\tfn" +(1727:11-1727:16) ".call" --> (1129:9-1129:14) ".call" +(1727:16-1727:21) "(Fake" --> (1129:14-1129:19) "(Fake" +(1727:21-1727:31) ".prototype" --> (1129:19-1129:29) ".prototype" +(1727:31-1728:7) ");\n " --> (1129:29-1130:5) ");\n\t\t\t\t" +(1728:7-1729:5) "}\n " --> (1130:5-1131:4) "\t}\n\t\t\t" +(1729:5-1729:11) "} else" --> (1131:4-1131:11) "\t} else" +(1729:11-1730:6) " {\n " --> (1131:11-1132:0) " {" +(1730:6-1730:10) " try" --> (1132:0-1132:9) "\n\t\t\t\t\ttry" +(1730:10-1731:8) " {\n " --> (1132:9-1133:0) " {" +(1731:8-1731:14) " throw" --> (1133:0-1133:12) "\n\t\t\t\t\t\tthrow" +(1731:14-1731:21) " Error(" --> (1133:12-1133:19) " Error(" +(1731:21-1732:7) ");\n " --> (1133:19-1134:5) ");\n\t\t\t\t" +(1732:7-1732:15) "} catch " --> (1134:5-1134:14) "\t} catch " +(1732:15-1732:18) "(x)" --> (1134:14-1134:17) "(x)" +(1732:18-1733:8) " {\n " --> (1134:17-1135:0) " {" +(1733:8-1733:18) " control =" --> (1135:0-1135:16) "\n\t\t\t\t\t\tcontrol =" +(1733:18-1734:7) " x;\n " --> (1135:16-1136:5) " x;\n\t\t\t\t" +(1734:7-1736:6) "}\n\n " --> (1136:5-1137:0) "\t}" +(1736:6-1736:10) " fn(" --> (1137:0-1137:9) "\n\t\t\t\t\tfn(" +(1736:10-1737:5) ");\n " --> (1137:9-1138:4) ");\n\t\t\t" +(1737:5-1738:3) "}\n " --> (1138:4-1139:3) "\t}\n\t\t" +(1738:3-1738:11) "} catch " --> (1139:3-1139:12) "\t} catch " +(1738:11-1738:19) "(sample)" --> (1139:12-1139:20) "(sample)" +(1738:19-1740:4) " {\n // This is inlined manually because closure doesn't do it for us.\n " --> (1139:20-1140:0) " {" +(1740:4-1740:8) " if " --> (1140:0-1140:8) "\n\t\t\t\tif " +(1740:8-1740:18) "(sample &&" --> (1140:8-1140:18) "(sample &&" +(1740:18-1740:36) " control && typeof" --> (1140:18-1140:36) " control && typeof" +(1740:36-1740:43) " sample" --> (1140:36-1140:43) " sample" +(1740:43-1740:53) ".stack ===" --> (1140:43-1140:53) ".stack ===" +(1740:53-1740:63) " 'string')" --> (1140:53-1140:63) " \"string\")" +(1740:63-1743:6) " {\n // This extracts the first frame from the sample that isn't also in the control.\n // Skipping one frame that we assume is the frame that calls the two.\n " --> (1140:63-1141:5) " {\n\t\t\t\t" +(1743:6-1743:10) " var" --> (1141:5-1141:9) "\tvar" +(1743:10-1743:24) " sampleLines =" --> (1141:9-1141:23) " sampleLines =" +(1743:24-1743:31) " sample" --> (1141:23-1141:30) " sample" +(1743:31-1743:37) ".stack" --> (1141:30-1141:36) ".stack" +(1743:37-1743:43) ".split" --> (1141:36-1141:42) ".split" +(1743:43-1743:48) "('\\n'" --> (1141:42-1141:47) "(\"\\n\"" +(1743:48-1744:6) ");\n " --> (1141:47-1142:5) ");\n\t\t\t\t" +(1744:6-1744:10) " var" --> (1142:5-1142:9) "\tvar" +(1744:10-1744:25) " controlLines =" --> (1142:9-1142:24) " controlLines =" +(1744:25-1744:33) " control" --> (1142:24-1142:32) " control" +(1744:33-1744:39) ".stack" --> (1142:32-1142:38) ".stack" +(1744:39-1744:45) ".split" --> (1142:38-1142:44) ".split" +(1744:45-1744:50) "('\\n'" --> (1142:44-1142:49) "(\"\\n\"" +(1744:50-1745:6) ");\n " --> (1142:49-1143:5) ");\n\t\t\t\t" +(1745:6-1745:10) " var" --> (1143:5-1143:9) "\tvar" +(1745:10-1745:14) " s =" --> (1143:9-1143:13) " s =" +(1745:14-1745:26) " sampleLines" --> (1143:13-1143:25) " sampleLines" +(1745:26-1745:35) ".length -" --> (1143:25-1143:34) ".length -" +(1745:35-1746:6) " 1;\n " --> (1143:34-1144:5) " 1;\n\t\t\t\t" +(1746:6-1746:10) " var" --> (1144:5-1144:9) "\tvar" +(1746:10-1746:14) " c =" --> (1144:9-1144:13) " c =" +(1746:14-1746:27) " controlLines" --> (1144:13-1144:26) " controlLines" +(1746:27-1746:36) ".length -" --> (1144:26-1144:35) ".length -" +(1746:36-1748:6) " 1;\n\n " --> (1144:35-1145:0) " 1;" +(1748:6-1748:13) " while " --> (1145:0-1145:12) "\n\t\t\t\t\twhile " +(1748:13-1748:18) "(s >=" --> (1145:12-1145:17) "(s >=" +(1748:18-1748:23) " 1 &&" --> (1145:17-1145:22) " 1 &&" +(1748:23-1748:28) " c >=" --> (1145:22-1145:27) " c >=" +(1748:28-1748:33) " 0 &&" --> (1145:27-1145:32) " 0 &&" +(1748:33-1748:45) " sampleLines" --> (1145:32-1145:44) " sampleLines" +(1748:45-1748:52) "[s] !==" --> (1145:44-1145:51) "[s] !==" +(1748:52-1748:65) " controlLines" --> (1145:51-1145:64) " controlLines" +(1748:65-1748:69) "[c])" --> (1145:64-1145:68) "[c])" +(1748:69-1755:8) " {\n // We expect at least one stack frame to be shared.\n // Typically this will be the root most one. However, stack frames may be\n // cut off due to maximum stack limits. In this case, one maybe cut off\n // earlier than the other. We assume that the sample is longer or the same\n // and there for cut off earlier. So we should find the root most frame in\n // the sample somewhere in the control.\n " --> (1145:68-1146:0) " {" +(1755:8-1756:7) " c--;\n " --> (1146:0-1147:5) "\n\t\t\t\t\t\tc--;\n\t\t\t\t" +(1756:7-1758:6) "}\n\n " --> (1147:5-1148:0) "\t}" +(1758:6-1758:13) " for (;" --> (1148:0-1148:12) "\n\t\t\t\t\tfor (;" +(1758:13-1758:18) " s >=" --> (1148:12-1148:17) " s >=" +(1758:18-1758:23) " 1 &&" --> (1148:17-1148:22) " 1 &&" +(1758:23-1758:28) " c >=" --> (1148:22-1148:27) " c >=" +(1758:28-1758:31) " 0;" --> (1148:27-1148:30) " 0;" +(1758:31-1758:36) " s--," --> (1148:30-1148:35) " s--," +(1758:36-1758:41) " c--)" --> (1148:35-1148:40) " c--)" +(1758:41-1761:8) " {\n // Next we find the first one that isn't the same which should be the\n // frame that called our sample function and the control.\n " --> (1148:40-1149:0) " {" +(1761:8-1761:12) " if " --> (1149:0-1149:10) "\n\t\t\t\t\t\tif " +(1761:12-1761:24) "(sampleLines" --> (1149:10-1149:22) "(sampleLines" +(1761:24-1761:31) "[s] !==" --> (1149:22-1149:29) "[s] !==" +(1761:31-1761:44) " controlLines" --> (1149:29-1149:42) " controlLines" +(1761:44-1761:48) "[c])" --> (1149:42-1149:46) "[c])" +(1761:48-1767:10) " {\n // In V8, the first line is describing the message but other VMs don't.\n // If we're about to return the first line, and the control is also on the same\n // line, that's a pretty good indicator that our sample threw at same line as\n // the control. I.e. before we entered the sample frame. So we ignore this result.\n // This can happen if you passed a class to function component, or non-function.\n " --> (1149:46-1150:0) " {" +(1767:10-1767:14) " if " --> (1150:0-1150:11) "\n\t\t\t\t\t\t\tif " +(1767:14-1767:20) "(s !==" --> (1150:11-1150:17) "(s !==" +(1767:20-1767:25) " 1 ||" --> (1150:17-1150:22) " 1 ||" +(1767:25-1767:31) " c !==" --> (1150:22-1150:28) " c !==" +(1767:31-1767:34) " 1)" --> (1150:28-1150:31) " 1)" +(1767:34-1768:12) " {\n " --> (1150:31-1151:0) " {" +(1768:12-1768:15) " do" --> (1151:0-1151:11) "\n\t\t\t\t\t\t\t\tdo" +(1768:15-1769:14) " {\n " --> (1151:11-1152:0) " {" +(1769:14-1770:14) " s--;\n " --> (1152:0-1153:0) "\n\t\t\t\t\t\t\t\t\ts--;" +(1770:14-1773:14) " c--; // We may still have similar intermediate frames from the construct call.\n // The next one that isn't the same should be our match though.\n\n " --> (1153:0-1154:0) "\n\t\t\t\t\t\t\t\t\tc--;" +(1773:14-1773:18) " if " --> (1154:0-1154:13) "\n\t\t\t\t\t\t\t\t\tif " +(1773:18-1773:22) "(c <" --> (1154:13-1154:17) "(c <" +(1773:22-1773:27) " 0 ||" --> (1154:17-1154:22) " 0 ||" +(1773:27-1773:39) " sampleLines" --> (1154:22-1154:34) " sampleLines" +(1773:39-1773:46) "[s] !==" --> (1154:34-1154:41) "[s] !==" +(1773:46-1773:59) " controlLines" --> (1154:41-1154:54) " controlLines" +(1773:59-1773:63) "[c])" --> (1154:54-1154:58) "[c])" +(1773:63-1775:16) " {\n // V8 adds a \"new\" prefix for native classes. Let's remove it to make it prettier.\n " --> (1154:58-1155:10) " {\n\t\t\t\t\t\t\t\t\t" +(1775:16-1775:20) " var" --> (1155:10-1155:14) "\tvar" +(1775:20-1775:29) " _frame =" --> (1155:14-1155:23) " _frame =" +(1775:29-1775:36) " '\\n' +" --> (1155:23-1155:30) " \"\\n\" +" +(1775:36-1775:48) " sampleLines" --> (1155:30-1155:42) " sampleLines" +(1775:48-1775:51) "[s]" --> (1155:42-1155:45) "[s]" +(1775:51-1775:59) ".replace" --> (1155:45-1155:53) ".replace" +(1775:59-1775:71) "(' at new '," --> (1155:53-1155:65) "(\" at new \"," +(1775:71-1775:78) " ' at '" --> (1155:65-1155:72) " \" at \"" +(1775:78-1777:16) ");\n\n " --> (1155:72-1156:10) ");\n\t\t\t\t\t\t\t\t\t" +(1777:16-1778:18) " {\n " --> (1156:10-1157:0) "\t{" +(1778:18-1778:29) " if (typeof" --> (1157:0-1157:22) "\n\t\t\t\t\t\t\t\t\t\t\tif (typeof" +(1778:29-1778:36) " fn ===" --> (1157:22-1157:29) " fn ===" +(1778:36-1778:48) " 'function')" --> (1157:29-1157:41) " \"function\")" +(1778:48-1779:20) " {\n " --> (1157:41-1158:0) " {" +(1779:20-1779:40) " componentFrameCache" --> (1158:0-1158:32) "\n\t\t\t\t\t\t\t\t\t\t\t\tcomponentFrameCache" +(1779:40-1779:44) ".set" --> (1158:32-1158:36) ".set" +(1779:44-1779:48) "(fn," --> (1158:36-1158:40) "(fn," +(1779:48-1779:55) " _frame" --> (1158:40-1158:47) " _frame" +(1779:55-1780:19) ");\n " --> (1158:47-1159:11) ");\n\t\t\t\t\t\t\t\t\t\t" +(1780:19-1781:17) "}\n " --> (1159:11-1160:10) "\t}\n\t\t\t\t\t\t\t\t\t" +(1781:17-1784:16) "} // Return the line we found.\n\n\n " --> (1160:10-1161:0) "\t}" +(1784:16-1784:23) " return" --> (1161:0-1161:17) "\n\t\t\t\t\t\t\t\t\t\treturn" +(1784:23-1785:15) " _frame;\n " --> (1161:17-1162:9) " _frame;\n\t\t\t\t\t\t\t\t" +(1785:15-1786:13) "}\n " --> (1162:9-1163:8) "\t}\n\t\t\t\t\t\t\t" +(1786:13-1786:21) "} while " --> (1163:8-1163:17) "\t} while " +(1786:21-1786:26) "(s >=" --> (1163:17-1163:22) "(s >=" +(1786:26-1786:31) " 1 &&" --> (1163:22-1163:27) " 1 &&" +(1786:31-1786:36) " c >=" --> (1163:27-1163:32) " c >=" +(1786:36-1787:11) " 0);\n " --> (1163:32-1164:7) " 0);\n\t\t\t\t\t\t" +(1787:11-1789:10) "}\n\n " --> (1164:7-1165:0) "\t}" +(1789:10-1790:9) " break;\n " --> (1165:0-1166:6) "\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t" +(1790:9-1791:7) "}\n " --> (1166:6-1167:5) "\t}\n\t\t\t\t" +(1791:7-1792:5) "}\n " --> (1167:5-1168:4) "\t}\n\t\t\t" +(1792:5-1793:3) "}\n " --> (1168:4-1169:3) "\t}\n\t\t" +(1793:3-1793:12) "} finally" --> (1169:3-1170:9) "\t}\n finally" +(1793:12-1794:4) " {\n " --> (1170:9-1171:0) " {" +(1794:4-1794:14) " reentry =" --> (1171:0-1171:14) "\n\t\t\t\treentry =" +(1794:14-1796:4) " false;\n\n " --> (1171:14-1172:4) " false;\n\t\t\t" +(1796:4-1797:6) " {\n " --> (1172:4-1173:0) "\t{" +(1797:6-1797:31) " ReactCurrentDispatcher$1" --> (1173:0-1173:30) "\n\t\t\t\t\tReactCurrentDispatcher$1" +(1797:31-1797:41) ".current =" --> (1173:30-1173:40) ".current =" +(1797:41-1798:6) " previousDispatcher;\n " --> (1173:40-1174:0) " previousDispatcher;" +(1798:6-1798:20) " reenableLogs(" --> (1174:0-1174:19) "\n\t\t\t\t\treenableLogs(" +(1798:20-1799:5) ");\n " --> (1174:19-1175:4) ");\n\t\t\t" +(1799:5-1801:4) "}\n\n " --> (1175:4-1176:0) "\t}" +(1801:4-1801:10) " Error" --> (1176:0-1176:10) "\n\t\t\t\tError" +(1801:10-1801:30) ".prepareStackTrace =" --> (1176:10-1176:30) ".prepareStackTrace =" +(1801:30-1802:3) " previousPrepareStackTrace;\n " --> (1176:30-1177:3) " previousPrepareStackTrace;\n\t\t" +(1802:3-1805:2) "} // Fallback to just using the name if we couldn't make it throw.\n\n\n " --> (1177:3-1178:3) "\t}\n\t\t" +(1805:2-1805:6) " var" --> (1178:3-1178:7) "\tvar" +(1805:6-1805:13) " name =" --> (1178:7-1178:14) " name =" +(1805:13-1805:18) " fn ?" --> (1178:14-1178:19) " fn ?" +(1805:18-1805:21) " fn" --> (1178:19-1178:22) " fn" +(1805:21-1805:36) ".displayName ||" --> (1178:22-1178:37) ".displayName ||" +(1805:36-1805:39) " fn" --> (1178:37-1178:40) " fn" +(1805:39-1805:46) ".name :" --> (1178:40-1178:47) ".name :" +(1805:46-1806:2) " '';\n " --> (1178:47-1179:3) " \"\";\n\t\t" +(1806:2-1806:6) " var" --> (1179:3-1179:7) "\tvar" +(1806:6-1806:23) " syntheticFrame =" --> (1179:7-1179:24) " syntheticFrame =" +(1806:23-1806:30) " name ?" --> (1179:24-1179:31) " name ?" +(1806:30-1806:60) " describeBuiltInComponentFrame" --> (1179:31-1179:61) " describeBuiltInComponentFrame" +(1806:60-1806:65) "(name" --> (1179:61-1179:66) "(name" +(1806:65-1806:68) ") :" --> (1179:66-1179:69) ") :" +(1806:68-1808:2) " '';\n\n " --> (1179:69-1180:3) " \"\";\n\t\t" +(1808:2-1809:4) " {\n " --> (1180:3-1181:0) "\t{" +(1809:4-1809:15) " if (typeof" --> (1181:0-1181:15) "\n\t\t\t\tif (typeof" +(1809:15-1809:22) " fn ===" --> (1181:15-1181:22) " fn ===" +(1809:22-1809:34) " 'function')" --> (1181:22-1181:34) " \"function\")" +(1809:34-1810:6) " {\n " --> (1181:34-1182:0) " {" +(1810:6-1810:26) " componentFrameCache" --> (1182:0-1182:25) "\n\t\t\t\t\tcomponentFrameCache" +(1810:26-1810:30) ".set" --> (1182:25-1182:29) ".set" +(1810:30-1810:34) "(fn," --> (1182:29-1182:33) "(fn," +(1810:34-1810:49) " syntheticFrame" --> (1182:33-1182:48) " syntheticFrame" +(1810:49-1811:5) ");\n " --> (1182:48-1183:4) ");\n\t\t\t" +(1811:5-1812:3) "}\n " --> (1183:4-1184:3) "\t}\n\t\t" +(1812:3-1814:2) "}\n\n " --> (1184:3-1185:0) "\t}" +(1814:2-1814:9) " return" --> (1185:0-1185:10) "\n\t\t\treturn" +(1814:9-1815:1) " syntheticFrame;\n" --> (1185:10-1186:2) " syntheticFrame;\n\t" +(1815:1-1816:0) "}" --> (1186:2-1187:2) "\t}\n\t" +(1816:0-1816:9) "\nfunction" --> (1187:2-1187:11) "\tfunction" +(1816:9-1816:40) " describeFunctionComponentFrame" --> (1187:11-1187:42) " describeFunctionComponentFrame" +(1816:40-1816:44) "(fn," --> (1187:42-1187:46) "(fn," +(1816:44-1816:52) " source," --> (1187:46-1187:54) " source," +(1816:52-1816:61) " ownerFn)" --> (1187:54-1187:63) " ownerFn)" +(1816:61-1817:2) " {\n " --> (1187:63-1188:3) " {\n\t\t" +(1817:2-1818:4) " {\n " --> (1188:3-1189:0) "\t{" +(1818:4-1818:11) " return" --> (1189:0-1189:11) "\n\t\t\t\treturn" +(1818:11-1818:40) " describeNativeComponentFrame" --> (1189:11-1189:40) " describeNativeComponentFrame" +(1818:40-1818:44) "(fn," --> (1189:40-1189:44) "(fn," +(1818:44-1818:50) " false" --> (1189:44-1189:50) " false" +(1818:50-1819:3) ");\n " --> (1189:50-1190:3) ");\n\t\t" +(1819:3-1820:1) "}\n" --> (1190:3-1191:2) "\t}\n\t" +(1820:1-1822:0) "}\n" --> (1191:2-1192:2) "\t}\n\t" +(1822:0-1822:9) "\nfunction" --> (1192:2-1192:11) "\tfunction" +(1822:9-1822:25) " shouldConstruct" --> (1192:11-1192:27) " shouldConstruct" +(1822:25-1822:36) "(Component)" --> (1192:27-1192:38) "(Component)" +(1822:36-1823:2) " {\n " --> (1192:38-1193:3) " {\n\t\t" +(1823:2-1823:6) " var" --> (1193:3-1193:7) "\tvar" +(1823:6-1823:18) " prototype =" --> (1193:7-1193:19) " prototype =" +(1823:18-1823:28) " Component" --> (1193:19-1193:29) " Component" +(1823:28-1824:2) ".prototype;\n " --> (1193:29-1194:0) ".prototype;" +(1824:2-1824:12) " return !!" --> (1194:0-1194:13) "\n\t\t\treturn !!" +(1824:12-1824:25) "(prototype &&" --> (1194:13-1194:26) "(prototype &&" +(1824:25-1824:35) " prototype" --> (1194:26-1194:36) " prototype" +(1824:35-1825:1) ".isReactComponent);\n" --> (1194:36-1195:2) ".isReactComponent);\n\t" +(1825:1-1827:0) "}\n" --> (1195:2-1196:2) "\t}\n\t" +(1827:0-1827:9) "\nfunction" --> (1196:2-1196:11) "\tfunction" +(1827:9-1827:46) " describeUnknownElementTypeFrameInDEV" --> (1196:11-1196:48) " describeUnknownElementTypeFrameInDEV" +(1827:46-1827:52) "(type," --> (1196:48-1196:54) "(type," +(1827:52-1827:60) " source," --> (1196:54-1196:62) " source," +(1827:60-1827:69) " ownerFn)" --> (1196:62-1196:71) " ownerFn)" +(1827:69-1829:2) " {\n\n " --> (1196:71-1197:0) " {" +(1829:2-1829:6) " if " --> (1197:0-1197:7) "\n\t\t\tif " +(1829:6-1829:14) "(type ==" --> (1197:7-1197:15) "(type ==" +(1829:14-1829:20) " null)" --> (1197:15-1197:21) " null)" +(1829:20-1830:4) " {\n " --> (1197:21-1198:0) " {" +(1830:4-1830:11) " return" --> (1198:0-1198:11) "\n\t\t\t\treturn" +(1830:11-1831:3) " '';\n " --> (1198:11-1199:3) " \"\";\n\t\t" +(1831:3-1833:2) "}\n\n " --> (1199:3-1200:0) "\t}" +(1833:2-1833:13) " if (typeof" --> (1200:0-1200:14) "\n\t\t\tif (typeof" +(1833:13-1833:22) " type ===" --> (1200:14-1200:23) " type ===" +(1833:22-1833:34) " 'function')" --> (1200:23-1200:35) " \"function\")" +(1833:34-1834:4) " {\n " --> (1200:35-1201:4) " {\n\t\t\t" +(1834:4-1835:6) " {\n " --> (1201:4-1202:0) "\t{" +(1835:6-1835:13) " return" --> (1202:0-1202:12) "\n\t\t\t\t\treturn" +(1835:13-1835:42) " describeNativeComponentFrame" --> (1202:12-1202:41) " describeNativeComponentFrame" +(1835:42-1835:48) "(type," --> (1202:41-1202:47) "(type," +(1835:48-1835:64) " shouldConstruct" --> (1202:47-1202:63) " shouldConstruct" +(1835:64-1835:69) "(type" --> (1202:63-1202:68) "(type" +(1835:69-1835:70) ")" --> (1202:68-1202:69) ")" +(1835:70-1836:5) ");\n " --> (1202:69-1203:4) ");\n\t\t\t" +(1836:5-1837:3) "}\n " --> (1203:4-1204:3) "\t}\n\t\t" +(1837:3-1839:2) "}\n\n " --> (1204:3-1205:0) "\t}" +(1839:2-1839:13) " if (typeof" --> (1205:0-1205:14) "\n\t\t\tif (typeof" +(1839:13-1839:22) " type ===" --> (1205:14-1205:23) " type ===" +(1839:22-1839:32) " 'string')" --> (1205:23-1205:33) " \"string\")" +(1839:32-1840:4) " {\n " --> (1205:33-1206:0) " {" +(1840:4-1840:11) " return" --> (1206:0-1206:11) "\n\t\t\t\treturn" +(1840:11-1840:41) " describeBuiltInComponentFrame" --> (1206:11-1206:41) " describeBuiltInComponentFrame" +(1840:41-1840:46) "(type" --> (1206:41-1206:46) "(type" +(1840:46-1841:3) ");\n " --> (1206:46-1207:3) ");\n\t\t" +(1841:3-1843:2) "}\n\n " --> (1207:3-1208:0) "\t}" +(1843:2-1843:10) " switch " --> (1208:0-1208:11) "\n\t\t\tswitch " +(1843:10-1843:2) " switch " --> (1208:11-1208:17) "(type)" +(1843:2-1844:4) " switch (type) {\n " --> (1208:17-1209:0) " {" +(1844:4-1844:9) " case" --> (1209:0-1209:9) "\n\t\t\t\tcase" +(1844:9-1844:17) " exports" --> (1209:9-1209:17) " exports" +(1844:17-1845:6) ".Suspense:\n " --> (1209:17-1210:0) ".Suspense:" +(1845:6-1845:13) " return" --> (1210:0-1210:12) "\n\t\t\t\t\treturn" +(1845:13-1845:43) " describeBuiltInComponentFrame" --> (1210:12-1210:42) " describeBuiltInComponentFrame" +(1845:43-1845:54) "('Suspense'" --> (1210:42-1210:53) "(\"Suspense\"" +(1845:54-1847:4) ");\n\n " --> (1210:53-1211:0) ");" +(1847:4-1847:9) " case" --> (1211:0-1211:9) "\n\t\t\t\tcase" +(1847:9-1848:6) " REACT_SUSPENSE_LIST_TYPE:\n " --> (1211:9-1212:0) " REACT_SUSPENSE_LIST_TYPE:" +(1848:6-1848:13) " return" --> (1212:0-1212:12) "\n\t\t\t\t\treturn" +(1848:13-1848:43) " describeBuiltInComponentFrame" --> (1212:12-1212:42) " describeBuiltInComponentFrame" +(1848:43-1848:58) "('SuspenseList'" --> (1212:42-1212:57) "(\"SuspenseList\"" +(1848:58-1849:3) ");\n " --> (1212:57-1213:3) ");\n\t\t" +(1849:3-1851:2) "}\n\n " --> (1213:3-1214:0) "\t}" +(1851:2-1851:13) " if (typeof" --> (1214:0-1214:14) "\n\t\t\tif (typeof" +(1851:13-1851:22) " type ===" --> (1214:14-1214:23) " type ===" +(1851:22-1851:32) " 'object')" --> (1214:23-1214:33) " \"object\")" +(1851:32-1852:4) " {\n " --> (1214:33-1215:0) " {" +(1852:4-1852:12) " switch " --> (1215:0-1215:12) "\n\t\t\t\tswitch " +(1852:12-1852:17) "(type" --> (1215:12-1215:17) "(type" +(1852:17-1852:4) " switch (type" --> (1215:17-1215:27) ".$$typeof)" +(1852:4-1853:6) " switch (type.$$typeof) {\n " --> (1215:27-1216:0) " {" +(1853:6-1853:11) " case" --> (1216:0-1216:10) "\n\t\t\t\t\tcase" +(1853:11-1854:8) " REACT_FORWARD_REF_TYPE:\n " --> (1216:10-1217:0) " REACT_FORWARD_REF_TYPE:" +(1854:8-1854:15) " return" --> (1217:0-1217:13) "\n\t\t\t\t\t\treturn" +(1854:15-1854:46) " describeFunctionComponentFrame" --> (1217:13-1217:44) " describeFunctionComponentFrame" +(1854:46-1854:51) "(type" --> (1217:44-1217:49) "(type" +(1854:51-1854:58) ".render" --> (1217:49-1217:56) ".render" +(1854:58-1856:6) ");\n\n " --> (1217:56-1218:0) ");" +(1856:6-1856:11) " case" --> (1218:0-1218:10) "\n\t\t\t\t\tcase" +(1856:11-1858:8) " REACT_MEMO_TYPE:\n // Memo may contain any component type so we recursively resolve it.\n " --> (1218:10-1219:0) " REACT_MEMO_TYPE:" +(1858:8-1858:15) " return" --> (1219:0-1219:13) "\n\t\t\t\t\t\treturn" +(1858:15-1858:52) " describeUnknownElementTypeFrameInDEV" --> (1219:13-1219:50) " describeUnknownElementTypeFrameInDEV" +(1858:52-1858:57) "(type" --> (1219:50-1219:55) "(type" +(1858:57-1858:63) ".type," --> (1219:55-1219:61) ".type," +(1858:63-1858:71) " source," --> (1219:61-1219:69) " source," +(1858:71-1858:79) " ownerFn" --> (1219:69-1219:77) " ownerFn" +(1858:79-1860:6) ");\n\n " --> (1219:77-1220:0) ");" +(1860:6-1860:11) " case" --> (1220:0-1220:10) "\n\t\t\t\t\tcase" +(1860:11-1861:8) " REACT_BLOCK_TYPE:\n " --> (1220:10-1221:0) " REACT_BLOCK_TYPE:" +(1861:8-1861:15) " return" --> (1221:0-1221:13) "\n\t\t\t\t\t\treturn" +(1861:15-1861:46) " describeFunctionComponentFrame" --> (1221:13-1221:44) " describeFunctionComponentFrame" +(1861:46-1861:51) "(type" --> (1221:44-1221:49) "(type" +(1861:51-1861:59) "._render" --> (1221:49-1221:57) "._render" +(1861:59-1863:6) ");\n\n " --> (1221:57-1222:0) ");" +(1863:6-1863:11) " case" --> (1222:0-1222:10) "\n\t\t\t\t\tcase" +(1863:11-1864:8) " REACT_LAZY_TYPE:\n " --> (1222:10-1223:6) " REACT_LAZY_TYPE:\n\t\t\t\t\t" +(1864:8-1865:10) " {\n " --> (1223:6-1224:7) "\t{\n\t\t\t\t\t\t" +(1865:10-1865:14) " var" --> (1224:7-1224:11) "\tvar" +(1865:14-1865:30) " lazyComponent =" --> (1224:11-1224:27) " lazyComponent =" +(1865:30-1866:10) " type;\n " --> (1224:27-1225:7) " type;\n\t\t\t\t\t\t" +(1866:10-1866:14) " var" --> (1225:7-1225:11) "\tvar" +(1866:14-1866:24) " payload =" --> (1225:11-1225:21) " payload =" +(1866:24-1866:38) " lazyComponent" --> (1225:21-1225:35) " lazyComponent" +(1866:38-1867:10) "._payload;\n " --> (1225:35-1226:7) "._payload;\n\t\t\t\t\t\t" +(1867:10-1867:14) " var" --> (1226:7-1226:11) "\tvar" +(1867:14-1867:21) " init =" --> (1226:11-1226:18) " init =" +(1867:21-1867:35) " lazyComponent" --> (1226:18-1226:32) " lazyComponent" +(1867:35-1869:10) "._init;\n\n " --> (1226:32-1227:0) "._init;" +(1869:10-1869:14) " try" --> (1227:0-1227:11) "\n\t\t\t\t\t\t\ttry" +(1869:14-1871:12) " {\n // Lazy may contain any component type so we recursively resolve it.\n " --> (1227:11-1228:0) " {" +(1871:12-1871:19) " return" --> (1228:0-1228:15) "\n\t\t\t\t\t\t\t\treturn" +(1871:19-1871:56) " describeUnknownElementTypeFrameInDEV" --> (1228:15-1228:52) " describeUnknownElementTypeFrameInDEV" +(1871:56-1871:61) "(init" --> (1228:52-1228:57) "(init" +(1871:61-1871:69) "(payload" --> (1228:57-1228:65) "(payload" +(1871:69-1871:71) ")," --> (1228:65-1228:67) ")," +(1871:71-1871:79) " source," --> (1228:67-1228:75) " source," +(1871:79-1871:87) " ownerFn" --> (1228:75-1228:83) " ownerFn" +(1871:87-1872:11) ");\n " --> (1228:83-1229:7) ");\n\t\t\t\t\t\t" +(1872:11-1872:19) "} catch " --> (1229:7-1229:16) "\t} catch " +(1872:19-1872:22) "(x)" --> (1229:16-1229:19) "(x)" +(1872:22-1872:24) " {" --> (1229:19-1229:20) " " +(1872:24-1873:9) "}\n " --> (1229:20-1230:6) "{}\n\t\t\t\t\t" +(1873:9-1874:5) "}\n " --> (1230:6-1231:4) "\t}\n\t\t\t" +(1874:5-1875:3) "}\n " --> (1231:4-1232:3) "\t}\n\t\t" +(1875:3-1877:2) "}\n\n " --> (1232:3-1233:0) "\t}" +(1877:2-1877:9) " return" --> (1233:0-1233:10) "\n\t\t\treturn" +(1877:9-1878:1) " '';\n" --> (1233:10-1234:2) " \"\";\n\t" +(1878:1-1880:0) "}\n" --> (1234:2-1235:2) "\t}\n\t" +(1880:0-1880:4) "\nvar" --> (1235:2-1235:6) "\tvar" +(1880:4-1880:25) " loggedTypeFailures =" --> (1235:6-1235:27) " loggedTypeFailures =" +(1880:25-1880:27) " {" --> (1235:27-1235:28) " " +(1880:27-1881:0) "};" --> (1235:28-1236:2) "{};\n\t" +(1881:0-1881:4) "\nvar" --> (1236:2-1236:6) "\tvar" +(1881:4-1881:31) " ReactDebugCurrentFrame$1 =" --> (1236:6-1236:33) " ReactDebugCurrentFrame$1 =" +(1881:31-1881:52) " ReactSharedInternals" --> (1236:33-1236:54) " ReactSharedInternals" +(1881:52-1883:0) ".ReactDebugCurrentFrame;\n" --> (1236:54-1237:2) ".ReactDebugCurrentFrame;\n\t" +(1883:0-1883:9) "\nfunction" --> (1237:2-1237:11) "\tfunction" +(1883:9-1883:39) " setCurrentlyValidatingElement" --> (1237:11-1237:41) " setCurrentlyValidatingElement" +(1883:39-1883:48) "(element)" --> (1237:41-1237:50) "(element)" +(1883:48-1884:2) " {\n " --> (1237:50-1238:3) " {\n\t\t" +(1884:2-1885:4) " {\n " --> (1238:3-1239:0) "\t{" +(1885:4-1885:8) " if " --> (1239:0-1239:8) "\n\t\t\t\tif " +(1885:8-1885:17) "(element)" --> (1239:8-1239:17) "(element)" +(1885:17-1886:6) " {\n " --> (1239:17-1240:5) " {\n\t\t\t\t" +(1886:6-1886:10) " var" --> (1240:5-1240:9) "\tvar" +(1886:10-1886:18) " owner =" --> (1240:9-1240:17) " owner =" +(1886:18-1886:26) " element" --> (1240:17-1240:25) " element" +(1886:26-1887:6) "._owner;\n " --> (1240:25-1241:5) "._owner;\n\t\t\t\t" +(1887:6-1887:10) " var" --> (1241:5-1241:9) "\tvar" +(1887:10-1887:18) " stack =" --> (1241:9-1241:17) " stack =" +(1887:18-1887:55) " describeUnknownElementTypeFrameInDEV" --> (1241:17-1241:54) " describeUnknownElementTypeFrameInDEV" +(1887:55-1887:63) "(element" --> (1241:54-1241:62) "(element" +(1887:63-1887:69) ".type," --> (1241:62-1241:68) ".type," +(1887:69-1887:77) " element" --> (1241:68-1241:76) " element" +(1887:77-1887:86) "._source," --> (1241:76-1241:85) "._source," +(1887:86-1887:94) " owner ?" --> (1241:85-1241:93) " owner ?" +(1887:94-1887:100) " owner" --> (1241:93-1241:99) " owner" +(1887:100-1887:107) ".type :" --> (1241:99-1241:106) ".type :" +(1887:107-1887:112) " null" --> (1241:106-1241:111) " null" +(1887:112-1888:6) ");\n " --> (1241:111-1242:0) ");" +(1888:6-1888:31) " ReactDebugCurrentFrame$1" --> (1242:0-1242:30) "\n\t\t\t\t\tReactDebugCurrentFrame$1" +(1888:31-1888:50) ".setExtraStackFrame" --> (1242:30-1242:49) ".setExtraStackFrame" +(1888:50-1888:56) "(stack" --> (1242:49-1242:55) "(stack" +(1888:56-1889:5) ");\n " --> (1242:55-1243:4) ");\n\t\t\t" +(1889:5-1889:11) "} else" --> (1243:4-1243:11) "\t} else" +(1889:11-1890:6) " {\n " --> (1243:11-1244:0) " {" +(1890:6-1890:31) " ReactDebugCurrentFrame$1" --> (1244:0-1244:30) "\n\t\t\t\t\tReactDebugCurrentFrame$1" +(1890:31-1890:50) ".setExtraStackFrame" --> (1244:30-1244:49) ".setExtraStackFrame" +(1890:50-1890:55) "(null" --> (1244:49-1244:54) "(null" +(1890:55-1891:5) ");\n " --> (1244:54-1245:4) ");\n\t\t\t" +(1891:5-1892:3) "}\n " --> (1245:4-1246:3) "\t}\n\t\t" +(1892:3-1893:1) "}\n" --> (1246:3-1247:2) "\t}\n\t" +(1893:1-1895:0) "}\n" --> (1247:2-1248:2) "\t}\n\t" +(1895:0-1895:9) "\nfunction" --> (1248:2-1248:11) "\tfunction" +(1895:9-1895:24) " checkPropTypes" --> (1248:11-1248:26) " checkPropTypes" +(1895:24-1895:35) "(typeSpecs," --> (1248:26-1248:37) "(typeSpecs," +(1895:35-1895:43) " values," --> (1248:37-1248:45) " values," +(1895:43-1895:53) " location," --> (1248:45-1248:55) " location," +(1895:53-1895:68) " componentName," --> (1248:55-1248:70) " componentName," +(1895:68-1895:77) " element)" --> (1248:70-1248:79) " element)" +(1895:77-1896:2) " {\n " --> (1248:79-1249:3) " {\n\t\t" +(1896:2-1898:4) " {\n // $FlowFixMe This is okay but Flow doesn't know it.\n " --> (1249:3-1250:4) "\t{\n\t\t\t" +(1898:4-1898:8) " var" --> (1250:4-1250:8) "\tvar" +(1898:8-1898:14) " has =" --> (1250:8-1250:14) " has =" +(1898:14-1898:23) " Function" --> (1250:14-1250:23) " Function" +(1898:23-1898:28) ".call" --> (1250:23-1250:28) ".call" +(1898:28-1898:33) ".bind" --> (1250:28-1250:33) ".bind" +(1898:33-1898:40) "(Object" --> (1250:33-1250:40) "(Object" +(1898:40-1898:50) ".prototype" --> (1250:40-1250:50) ".prototype" +(1898:50-1898:65) ".hasOwnProperty" --> (1250:50-1250:65) ".hasOwnProperty" +(1898:65-1900:4) ");\n\n " --> (1250:65-1251:0) ");" +(1900:4-1900:9) " for " --> (1251:0-1251:9) "\n\t\t\t\tfor " +(1900:9-1900:13) "(var" --> (1251:9-1251:13) "(var" +(1900:13-1900:29) " typeSpecName in" --> (1251:13-1251:29) " typeSpecName in" +(1900:29-1900:40) " typeSpecs)" --> (1251:29-1251:40) " typeSpecs)" +(1900:40-1901:6) " {\n " --> (1251:40-1252:0) " {" +(1901:6-1901:10) " if " --> (1252:0-1252:9) "\n\t\t\t\t\tif " +(1901:10-1901:14) "(has" --> (1252:9-1252:13) "(has" +(1901:14-1901:25) "(typeSpecs," --> (1252:13-1252:24) "(typeSpecs," +(1901:25-1901:38) " typeSpecName" --> (1252:24-1252:37) " typeSpecName" +(1901:38-1901:40) "))" --> (1252:37-1252:39) "))" +(1901:40-1902:8) " {\n " --> (1252:39-1253:6) " {\n\t\t\t\t\t" +(1902:8-1902:12) " var" --> (1253:6-1253:10) "\tvar" +(1902:12-1902:27) " error$1 = void" --> (1253:10-1253:25) " error$1 = void" +(1902:27-1906:8) " 0; // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n\n " --> (1253:25-1254:0) " 0;" +(1906:8-1906:12) " try" --> (1254:0-1254:10) "\n\t\t\t\t\t\ttry" +(1906:12-1909:10) " {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n " --> (1254:10-1255:0) " {" +(1909:10-1909:21) " if (typeof" --> (1255:0-1255:18) "\n\t\t\t\t\t\t\tif (typeof" +(1909:21-1909:31) " typeSpecs" --> (1255:18-1255:28) " typeSpecs" +(1909:31-1909:49) "[typeSpecName] !==" --> (1255:28-1255:46) "[typeSpecName] !==" +(1909:49-1909:61) " 'function')" --> (1255:46-1255:58) " \"function\")" +(1909:61-1910:12) " {\n " --> (1255:58-1256:8) " {\n\t\t\t\t\t\t\t" +(1910:12-1910:16) " var" --> (1256:8-1256:12) "\tvar" +(1910:16-1910:22) " err =" --> (1256:12-1256:18) " err =" +(1910:22-1910:29) " Error(" --> (1256:18-1256:25) " Error(" +(1910:29-1910:46) "(componentName ||" --> (1256:25-1256:42) "(componentName ||" +(1910:46-1910:63) " 'React class') +" --> (1256:42-1256:59) " \"React class\") +" +(1910:63-1910:70) " ': ' +" --> (1256:59-1256:66) " \": \" +" +(1910:70-1910:81) " location +" --> (1256:66-1256:77) " location +" +(1910:81-1910:93) " ' type `' +" --> (1256:77-1256:89) " \" type `\" +" +(1910:93-1910:108) " typeSpecName +" --> (1256:89-1256:104) " typeSpecName +" +(1910:108-1910:127) " '` is invalid; ' +" --> (1256:104-1256:123) " \"` is invalid; \" +" +(1910:127-1910:215) " 'it must be a function, usually from the `prop-types` package, but received `' + typeof" --> (1256:123-1256:211) " \"it must be a function, usually from the `prop-types` package, but received `\" + typeof" +(1910:215-1910:225) " typeSpecs" --> (1256:211-1256:221) " typeSpecs" +(1910:225-1910:241) "[typeSpecName] +" --> (1256:221-1256:237) "[typeSpecName] +" +(1910:241-1910:248) " '`.' +" --> (1256:237-1256:244) " \"`.\" +" +(1910:248-1910:344) " 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'" --> (1256:244-1256:340) " \"This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.\"" +(1910:344-1911:12) ");\n " --> (1256:340-1257:0) ");" +(1911:12-1911:16) " err" --> (1257:0-1257:12) "\n\t\t\t\t\t\t\t\terr" +(1911:16-1911:23) ".name =" --> (1257:12-1257:19) ".name =" +(1911:23-1912:12) " 'Invariant Violation';\n " --> (1257:19-1258:0) " \"Invariant Violation\";" +(1912:12-1912:18) " throw" --> (1258:0-1258:14) "\n\t\t\t\t\t\t\t\tthrow" +(1912:18-1913:11) " err;\n " --> (1258:14-1259:7) " err;\n\t\t\t\t\t\t" +(1913:11-1915:10) "}\n\n " --> (1259:7-1260:0) "\t}" +(1915:10-1915:20) " error$1 =" --> (1260:0-1260:17) "\n\t\t\t\t\t\t\terror$1 =" +(1915:20-1915:30) " typeSpecs" --> (1260:17-1260:27) " typeSpecs" +(1915:30-1915:44) "[typeSpecName]" --> (1260:27-1260:41) "[typeSpecName]" +(1915:44-1915:52) "(values," --> (1260:41-1260:49) "(values," +(1915:52-1915:66) " typeSpecName," --> (1260:49-1260:63) " typeSpecName," +(1915:66-1915:81) " componentName," --> (1260:63-1260:78) " componentName," +(1915:81-1915:91) " location," --> (1260:78-1260:88) " location," +(1915:91-1915:97) " null," --> (1260:88-1260:94) " null," +(1915:97-1915:144) " 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'" --> (1260:94-1260:141) " \"SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED\"" +(1915:144-1916:9) ");\n " --> (1260:141-1261:6) ");\n\t\t\t\t\t" +(1916:9-1916:17) "} catch " --> (1261:6-1261:15) "\t} catch " +(1916:17-1916:21) "(ex)" --> (1261:15-1261:19) "(ex)" +(1916:21-1917:10) " {\n " --> (1261:19-1262:0) " {" +(1917:10-1917:20) " error$1 =" --> (1262:0-1262:17) "\n\t\t\t\t\t\t\terror$1 =" +(1917:20-1918:9) " ex;\n " --> (1262:17-1263:6) " ex;\n\t\t\t\t\t" +(1918:9-1920:8) "}\n\n " --> (1263:6-1264:0) "\t}" +(1920:8-1920:12) " if " --> (1264:0-1264:10) "\n\t\t\t\t\t\tif " +(1920:12-1920:25) "(error$1 && !" --> (1264:10-1264:23) "(error$1 && !" +(1920:25-1920:44) "(error$1 instanceof" --> (1264:23-1264:42) "(error$1 instanceof" +(1920:44-1920:52) " Error))" --> (1264:42-1264:50) " Error))" +(1920:52-1921:10) " {\n " --> (1264:50-1265:0) " {" +(1921:10-1921:40) " setCurrentlyValidatingElement" --> (1265:0-1265:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" +(1921:40-1921:48) "(element" --> (1265:37-1265:45) "(element" +(1921:48-1923:10) ");\n\n " --> (1265:45-1266:0) ");" +(1923:10-1923:16) " error" --> (1266:0-1266:13) "\n\t\t\t\t\t\t\terror" +(1923:16-1923:49) "('%s: type specification of %s' +" --> (1266:13-1266:46) "(\"%s: type specification of %s\" +" +(1923:49-1923:89) " ' `%s` is invalid; the type checker ' +" --> (1266:46-1266:86) " \" `%s` is invalid; the type checker \" +" +(1923:89-1923:155) " 'function must return `null` or an `Error` but returned a %s. ' +" --> (1266:86-1266:152) " \"function must return `null` or an `Error` but returned a %s. \" +" +(1923:155-1923:223) " 'You may have forgotten to pass an argument to the type checker ' +" --> (1266:152-1266:220) " \"You may have forgotten to pass an argument to the type checker \" +" +(1923:223-1923:290) " 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +" --> (1266:220-1266:287) " \"creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and \" +" +(1923:290-1923:325) " 'shape all require an argument).'," --> (1266:287-1266:322) " \"shape all require an argument).\"," +(1923:325-1923:342) " componentName ||" --> (1266:322-1266:339) " componentName ||" +(1923:342-1923:357) " 'React class'," --> (1266:339-1266:354) " \"React class\"," +(1923:357-1923:367) " location," --> (1266:354-1266:364) " location," +(1923:367-1923:388) " typeSpecName, typeof" --> (1266:364-1266:385) " typeSpecName, typeof" +(1923:388-1923:396) " error$1" --> (1266:385-1266:393) " error$1" +(1923:396-1925:10) ");\n\n " --> (1266:393-1267:0) ");" +(1925:10-1925:40) " setCurrentlyValidatingElement" --> (1267:0-1267:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" +(1925:40-1925:45) "(null" --> (1267:37-1267:42) "(null" +(1925:45-1926:9) ");\n " --> (1267:42-1268:6) ");\n\t\t\t\t\t" +(1926:9-1928:8) "}\n\n " --> (1268:6-1269:0) "\t}" +(1928:8-1928:12) " if " --> (1269:0-1269:10) "\n\t\t\t\t\t\tif " +(1928:12-1928:31) "(error$1 instanceof" --> (1269:10-1269:29) "(error$1 instanceof" +(1928:31-1928:42) " Error && !" --> (1269:29-1269:40) " Error && !" +(1928:42-1928:50) "(error$1" --> (1269:40-1269:48) "(error$1" +(1928:50-1928:61) ".message in" --> (1269:48-1269:59) ".message in" +(1928:61-1928:82) " loggedTypeFailures))" --> (1269:59-1269:80) " loggedTypeFailures))" +(1928:82-1931:10) " {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n " --> (1269:80-1270:0) " {" +(1931:10-1931:29) " loggedTypeFailures" --> (1270:0-1270:26) "\n\t\t\t\t\t\t\tloggedTypeFailures" +(1931:29-1931:37) "[error$1" --> (1270:26-1270:34) "[error$1" +(1931:37-1931:48) ".message] =" --> (1270:34-1270:45) ".message] =" +(1931:48-1932:10) " true;\n " --> (1270:45-1271:0) " true;" +(1932:10-1932:40) " setCurrentlyValidatingElement" --> (1271:0-1271:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" +(1932:40-1932:48) "(element" --> (1271:37-1271:45) "(element" +(1932:48-1934:10) ");\n\n " --> (1271:45-1272:0) ");" +(1934:10-1934:16) " error" --> (1272:0-1272:13) "\n\t\t\t\t\t\t\terror" +(1934:16-1934:38) "('Failed %s type: %s'," --> (1272:13-1272:35) "(\"Failed %s type: %s\"," +(1934:38-1934:48) " location," --> (1272:35-1272:45) " location," +(1934:48-1934:56) " error$1" --> (1272:45-1272:53) " error$1" +(1934:56-1934:64) ".message" --> (1272:53-1272:61) ".message" +(1934:64-1936:10) ");\n\n " --> (1272:61-1273:0) ");" +(1936:10-1936:40) " setCurrentlyValidatingElement" --> (1273:0-1273:37) "\n\t\t\t\t\t\t\tsetCurrentlyValidatingElement" +(1936:40-1936:45) "(null" --> (1273:37-1273:42) "(null" +(1936:45-1937:9) ");\n " --> (1273:42-1274:6) ");\n\t\t\t\t\t" +(1937:9-1938:7) "}\n " --> (1274:6-1275:5) "\t}\n\t\t\t\t" +(1938:7-1939:5) "}\n " --> (1275:5-1276:4) "\t}\n\t\t\t" +(1939:5-1940:3) "}\n " --> (1276:4-1277:3) "\t}\n\t\t" +(1940:3-1941:1) "}\n" --> (1277:3-1278:2) "\t}\n\t" +(1941:1-1943:0) "}\n" --> (1278:2-1279:2) "\t}\n\t" +(1943:0-1943:9) "\nfunction" --> (1279:2-1279:11) "\tfunction" +(1943:9-1943:41) " setCurrentlyValidatingElement$1" --> (1279:11-1279:43) " setCurrentlyValidatingElement$1" +(1943:41-1943:50) "(element)" --> (1279:43-1279:52) "(element)" +(1943:50-1944:2) " {\n " --> (1279:52-1280:3) " {\n\t\t" +(1944:2-1945:4) " {\n " --> (1280:3-1281:0) "\t{" +(1945:4-1945:8) " if " --> (1281:0-1281:8) "\n\t\t\t\tif " +(1945:8-1945:17) "(element)" --> (1281:8-1281:17) "(element)" +(1945:17-1946:6) " {\n " --> (1281:17-1282:5) " {\n\t\t\t\t" +(1946:6-1946:10) " var" --> (1282:5-1282:9) "\tvar" +(1946:10-1946:18) " owner =" --> (1282:9-1282:17) " owner =" +(1946:18-1946:26) " element" --> (1282:17-1282:25) " element" +(1946:26-1947:6) "._owner;\n " --> (1282:25-1283:5) "._owner;\n\t\t\t\t" +(1947:6-1947:10) " var" --> (1283:5-1283:9) "\tvar" +(1947:10-1947:18) " stack =" --> (1283:9-1283:17) " stack =" +(1947:18-1947:55) " describeUnknownElementTypeFrameInDEV" --> (1283:17-1283:54) " describeUnknownElementTypeFrameInDEV" +(1947:55-1947:63) "(element" --> (1283:54-1283:62) "(element" +(1947:63-1947:69) ".type," --> (1283:62-1283:68) ".type," +(1947:69-1947:77) " element" --> (1283:68-1283:76) " element" +(1947:77-1947:86) "._source," --> (1283:76-1283:85) "._source," +(1947:86-1947:94) " owner ?" --> (1283:85-1283:93) " owner ?" +(1947:94-1947:100) " owner" --> (1283:93-1283:99) " owner" +(1947:100-1947:107) ".type :" --> (1283:99-1283:106) ".type :" +(1947:107-1947:112) " null" --> (1283:106-1283:111) " null" +(1947:112-1948:6) ");\n " --> (1283:111-1284:0) ");" +(1948:6-1948:25) " setExtraStackFrame" --> (1284:0-1284:24) "\n\t\t\t\t\tsetExtraStackFrame" +(1948:25-1948:31) "(stack" --> (1284:24-1284:30) "(stack" +(1948:31-1949:5) ");\n " --> (1284:30-1285:4) ");\n\t\t\t" +(1949:5-1949:11) "} else" --> (1285:4-1285:11) "\t} else" +(1949:11-1950:6) " {\n " --> (1285:11-1286:0) " {" +(1950:6-1950:25) " setExtraStackFrame" --> (1286:0-1286:24) "\n\t\t\t\t\tsetExtraStackFrame" +(1950:25-1950:30) "(null" --> (1286:24-1286:29) "(null" +(1950:30-1951:5) ");\n " --> (1286:29-1287:4) ");\n\t\t\t" +(1951:5-1952:3) "}\n " --> (1287:4-1288:3) "\t}\n\t\t" +(1952:3-1953:1) "}\n" --> (1288:3-1289:2) "\t}\n\t" +(1953:1-1955:0) "}\n" --> (1289:2-1290:2) "\t}\n\t" +(1955:0-1955:4) "\nvar" --> (1290:2-1290:6) "\tvar" +(1955:4-1957:0) " propTypesMisspellWarningShown;\n" --> (1290:6-1291:2) " propTypesMisspellWarningShown;\n\t" +(1957:0-1958:2) "\n{\n " --> (1291:2-1292:0) "\t{" +(1958:2-1958:34) " propTypesMisspellWarningShown =" --> (1292:0-1292:35) "\n\t\t\tpropTypesMisspellWarningShown =" +(1958:34-1959:1) " false;\n" --> (1292:35-1293:2) " false;\n\t" +(1959:1-1961:0) "}\n" --> (1293:2-1294:2) "\t}\n\t" +(1961:0-1961:9) "\nfunction" --> (1294:2-1294:11) "\tfunction" +(1961:9-1961:39) " getDeclarationErrorAddendum()" --> (1294:11-1294:41) " getDeclarationErrorAddendum()" +(1961:39-1962:2) " {\n " --> (1294:41-1295:0) " {" +(1962:2-1962:6) " if " --> (1295:0-1295:7) "\n\t\t\tif " +(1962:6-1962:24) "(ReactCurrentOwner" --> (1295:7-1295:25) "(ReactCurrentOwner" +(1962:24-1962:33) ".current)" --> (1295:25-1295:34) ".current)" +(1962:33-1963:4) " {\n " --> (1295:34-1296:4) " {\n\t\t\t" +(1963:4-1963:8) " var" --> (1296:4-1296:8) "\tvar" +(1963:8-1963:15) " name =" --> (1296:8-1296:15) " name =" +(1963:15-1963:32) " getComponentName" --> (1296:15-1296:32) " getComponentName" +(1963:32-1963:50) "(ReactCurrentOwner" --> (1296:32-1296:50) "(ReactCurrentOwner" +(1963:50-1963:58) ".current" --> (1296:50-1296:58) ".current" +(1963:58-1963:63) ".type" --> (1296:58-1296:63) ".type" +(1963:63-1965:4) ");\n\n " --> (1296:63-1297:0) ");" +(1965:4-1965:8) " if " --> (1297:0-1297:8) "\n\t\t\t\tif " +(1965:8-1965:14) "(name)" --> (1297:8-1297:14) "(name)" +(1965:14-1966:6) " {\n " --> (1297:14-1298:0) " {" +(1966:6-1966:13) " return" --> (1298:0-1298:12) "\n\t\t\t\t\treturn" +(1966:13-1966:50) " '\\n\\nCheck the render method of `' +" --> (1298:12-1298:49) " \"\\n\\nCheck the render method of `\" +" +(1966:50-1966:57) " name +" --> (1298:49-1298:56) " name +" +(1966:57-1967:5) " '`.';\n " --> (1298:56-1299:4) " \"`.\";\n\t\t\t" +(1967:5-1968:3) "}\n " --> (1299:4-1300:3) "\t}\n\t\t" +(1968:3-1970:2) "}\n\n " --> (1300:3-1301:0) "\t}" +(1970:2-1970:9) " return" --> (1301:0-1301:10) "\n\t\t\treturn" +(1970:9-1971:1) " '';\n" --> (1301:10-1302:2) " \"\";\n\t" +(1971:1-1973:0) "}\n" --> (1302:2-1303:2) "\t}\n\t" +(1973:0-1973:9) "\nfunction" --> (1303:2-1303:11) "\tfunction" +(1973:9-1973:36) " getSourceInfoErrorAddendum" --> (1303:11-1303:38) " getSourceInfoErrorAddendum" +(1973:36-1973:44) "(source)" --> (1303:38-1303:46) "(source)" +(1973:44-1974:2) " {\n " --> (1303:46-1304:0) " {" +(1974:2-1974:6) " if " --> (1304:0-1304:7) "\n\t\t\tif " +(1974:6-1974:17) "(source !==" --> (1304:7-1304:18) "(source !==" +(1974:17-1974:28) " undefined)" --> (1304:18-1304:29) " undefined)" +(1974:28-1975:4) " {\n " --> (1304:29-1305:4) " {\n\t\t\t" +(1975:4-1975:8) " var" --> (1305:4-1305:8) "\tvar" +(1975:8-1975:19) " fileName =" --> (1305:8-1305:19) " fileName =" +(1975:19-1975:26) " source" --> (1305:19-1305:26) " source" +(1975:26-1975:35) ".fileName" --> (1305:26-1305:35) ".fileName" +(1975:35-1975:43) ".replace" --> (1305:35-1305:43) ".replace" +(1975:43-1975:56) "(/^.*[\\\\\\/]/," --> (1305:43-1305:56) "(/^.*[\\\\\\/]/," +(1975:56-1975:59) " ''" --> (1305:56-1305:59) " \"\"" +(1975:59-1976:4) ");\n " --> (1305:59-1306:4) ");\n\t\t\t" +(1976:4-1976:8) " var" --> (1306:4-1306:8) "\tvar" +(1976:8-1976:21) " lineNumber =" --> (1306:8-1306:21) " lineNumber =" +(1976:21-1976:28) " source" --> (1306:21-1306:28) " source" +(1976:28-1977:4) ".lineNumber;\n " --> (1306:28-1307:0) ".lineNumber;" +(1977:4-1977:11) " return" --> (1307:0-1307:11) "\n\t\t\t\treturn" +(1977:11-1977:39) " '\\n\\nCheck your code at ' +" --> (1307:11-1307:39) " \"\\n\\nCheck your code at \" +" +(1977:39-1977:50) " fileName +" --> (1307:39-1307:50) " fileName +" +(1977:50-1977:56) " ':' +" --> (1307:50-1307:56) " \":\" +" +(1977:56-1977:69) " lineNumber +" --> (1307:56-1307:69) " lineNumber +" +(1977:69-1978:3) " '.';\n " --> (1307:69-1308:3) " \".\";\n\t\t" +(1978:3-1980:2) "}\n\n " --> (1308:3-1309:0) "\t}" +(1980:2-1980:9) " return" --> (1309:0-1309:10) "\n\t\t\treturn" +(1980:9-1981:1) " '';\n" --> (1309:10-1310:2) " \"\";\n\t" +(1981:1-1983:0) "}\n" --> (1310:2-1311:2) "\t}\n\t" +(1983:0-1983:9) "\nfunction" --> (1311:2-1311:11) "\tfunction" +(1983:9-1983:44) " getSourceInfoErrorAddendumForProps" --> (1311:11-1311:46) " getSourceInfoErrorAddendumForProps" +(1983:44-1983:58) "(elementProps)" --> (1311:46-1311:60) "(elementProps)" +(1983:58-1984:2) " {\n " --> (1311:60-1312:0) " {" +(1984:2-1984:6) " if " --> (1312:0-1312:7) "\n\t\t\tif " +(1984:6-1984:23) "(elementProps !==" --> (1312:7-1312:24) "(elementProps !==" +(1984:23-1984:31) " null &&" --> (1312:24-1312:32) " null &&" +(1984:31-1984:48) " elementProps !==" --> (1312:32-1312:49) " elementProps !==" +(1984:48-1984:59) " undefined)" --> (1312:49-1312:60) " undefined)" +(1984:59-1985:4) " {\n " --> (1312:60-1313:0) " {" +(1985:4-1985:11) " return" --> (1313:0-1313:11) "\n\t\t\t\treturn" +(1985:11-1985:38) " getSourceInfoErrorAddendum" --> (1313:11-1313:38) " getSourceInfoErrorAddendum" +(1985:38-1985:51) "(elementProps" --> (1313:38-1313:51) "(elementProps" +(1985:51-1985:60) ".__source" --> (1313:51-1313:60) ".__source" +(1985:60-1986:3) ");\n " --> (1313:60-1314:3) ");\n\t\t" +(1986:3-1988:2) "}\n\n " --> (1314:3-1315:0) "\t}" +(1988:2-1988:9) " return" --> (1315:0-1315:10) "\n\t\t\treturn" +(1988:9-1989:1) " '';\n" --> (1315:10-1316:2) " \"\";\n\t" +(1989:1-1997:0) "}\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\n\n" --> (1316:2-1317:2) "\t}\n\t" +(1997:0-1997:4) "\nvar" --> (1317:2-1317:6) "\tvar" +(1997:4-1997:28) " ownerHasKeyUseWarning =" --> (1317:6-1317:30) " ownerHasKeyUseWarning =" +(1997:28-1997:30) " {" --> (1317:30-1317:31) " " +(1997:30-1999:0) "};\n" --> (1317:31-1318:2) "{};\n\t" +(1999:0-1999:9) "\nfunction" --> (1318:2-1318:11) "\tfunction" +(1999:9-1999:38) " getCurrentComponentErrorInfo" --> (1318:11-1318:40) " getCurrentComponentErrorInfo" +(1999:38-1999:50) "(parentType)" --> (1318:40-1318:52) "(parentType)" +(1999:50-2000:2) " {\n " --> (1318:52-1319:3) " {\n\t\t" +(2000:2-2000:6) " var" --> (1319:3-1319:7) "\tvar" +(2000:6-2000:13) " info =" --> (1319:7-1319:14) " info =" +(2000:13-2000:42) " getDeclarationErrorAddendum(" --> (1319:14-1319:43) " getDeclarationErrorAddendum(" +(2000:42-2002:2) ");\n\n " --> (1319:43-1320:0) ");" +(2002:2-2002:7) " if (" --> (1320:0-1320:8) "\n\t\t\tif (" +(2002:7-2002:13) "!info)" --> (1320:8-1320:14) "!info)" +(2002:13-2003:4) " {\n " --> (1320:14-1321:4) " {\n\t\t\t" +(2003:4-2003:8) " var" --> (1321:4-1321:8) "\tvar" +(2003:8-2003:28) " parentName = typeof" --> (1321:8-1321:28) " parentName = typeof" +(2003:28-2003:43) " parentType ===" --> (1321:28-1321:43) " parentType ===" +(2003:43-2003:54) " 'string' ?" --> (1321:43-1321:54) " \"string\" ?" +(2003:54-2003:67) " parentType :" --> (1321:54-1321:67) " parentType :" +(2003:67-2003:78) " parentType" --> (1321:67-1321:78) " parentType" +(2003:78-2003:93) ".displayName ||" --> (1321:78-1321:93) ".displayName ||" +(2003:93-2003:104) " parentType" --> (1321:93-1321:104) " parentType" +(2003:104-2005:4) ".name;\n\n " --> (1321:104-1322:0) ".name;" +(2005:4-2005:8) " if " --> (1322:0-1322:8) "\n\t\t\t\tif " +(2005:8-2005:20) "(parentName)" --> (1322:8-1322:20) "(parentName)" +(2005:20-2006:6) " {\n " --> (1322:20-1323:0) " {" +(2006:6-2006:13) " info =" --> (1323:0-1323:12) "\n\t\t\t\t\tinfo =" +(2006:13-2006:61) " \"\\n\\nCheck the top-level render call using <\" +" --> (1323:12-1323:60) " \"\\n\\nCheck the top-level render call using <\" +" +(2006:61-2006:74) " parentName +" --> (1323:60-1323:73) " parentName +" +(2006:74-2007:5) " \">.\";\n " --> (1323:73-1324:4) " \">.\";\n\t\t\t" +(2007:5-2008:3) "}\n " --> (1324:4-1325:3) "\t}\n\t\t" +(2008:3-2010:2) "}\n\n " --> (1325:3-1326:0) "\t}" +(2010:2-2010:9) " return" --> (1326:0-1326:10) "\n\t\t\treturn" +(2010:9-2011:1) " info;\n" --> (1326:10-1327:2) " info;\n\t" +(2011:1-2025:0) "}\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it. Error statuses are cached so a warning\n * will only be shown once.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\n\n" --> (1327:2-1328:2) "\t}\n\t" +(2025:0-2025:9) "\nfunction" --> (1328:2-1328:11) "\tfunction" +(2025:9-2025:29) " validateExplicitKey" --> (1328:11-1328:31) " validateExplicitKey" +(2025:29-2025:38) "(element," --> (1328:31-1328:40) "(element," +(2025:38-2025:50) " parentType)" --> (1328:40-1328:52) " parentType)" +(2025:50-2026:2) " {\n " --> (1328:52-1329:0) " {" +(2026:2-2026:7) " if (" --> (1329:0-1329:8) "\n\t\t\tif (" +(2026:7-2026:15) "!element" --> (1329:8-1329:16) "!element" +(2026:15-2026:25) "._store ||" --> (1329:16-1329:26) "._store ||" +(2026:25-2026:33) " element" --> (1329:26-1329:34) " element" +(2026:33-2026:40) "._store" --> (1329:34-1329:41) "._store" +(2026:40-2026:53) ".validated ||" --> (1329:41-1329:54) ".validated ||" +(2026:53-2026:61) " element" --> (1329:54-1329:62) " element" +(2026:61-2026:68) ".key !=" --> (1329:62-1329:69) ".key !=" +(2026:68-2026:74) " null)" --> (1329:69-1329:75) " null)" +(2026:74-2027:4) " {\n " --> (1329:75-1330:0) " {" +(2027:4-2028:3) " return;\n " --> (1330:0-1331:3) "\n\t\t\t\treturn;\n\t\t" +(2028:3-2030:2) "}\n\n " --> (1331:3-1332:0) "\t}" +(2030:2-2030:10) " element" --> (1332:0-1332:11) "\n\t\t\telement" +(2030:10-2030:17) "._store" --> (1332:11-1332:18) "._store" +(2030:17-2030:29) ".validated =" --> (1332:18-1332:30) ".validated =" +(2030:29-2031:2) " true;\n " --> (1332:30-1333:3) " true;\n\t\t" +(2031:2-2031:6) " var" --> (1333:3-1333:7) "\tvar" +(2031:6-2031:34) " currentComponentErrorInfo =" --> (1333:7-1333:35) " currentComponentErrorInfo =" +(2031:34-2031:63) " getCurrentComponentErrorInfo" --> (1333:35-1333:64) " getCurrentComponentErrorInfo" +(2031:63-2031:74) "(parentType" --> (1333:64-1333:75) "(parentType" +(2031:74-2033:2) ");\n\n " --> (1333:75-1334:0) ");" +(2033:2-2033:6) " if " --> (1334:0-1334:7) "\n\t\t\tif " +(2033:6-2033:28) "(ownerHasKeyUseWarning" --> (1334:7-1334:29) "(ownerHasKeyUseWarning" +(2033:28-2033:56) "[currentComponentErrorInfo])" --> (1334:29-1334:57) "[currentComponentErrorInfo])" +(2033:56-2034:4) " {\n " --> (1334:57-1335:0) " {" +(2034:4-2035:3) " return;\n " --> (1335:0-1336:3) "\n\t\t\t\treturn;\n\t\t" +(2035:3-2037:2) "}\n\n " --> (1336:3-1337:0) "\t}" +(2037:2-2037:24) " ownerHasKeyUseWarning" --> (1337:0-1337:25) "\n\t\t\townerHasKeyUseWarning" +(2037:24-2037:53) "[currentComponentErrorInfo] =" --> (1337:25-1337:54) "[currentComponentErrorInfo] =" +(2037:53-2041:2) " true; // Usually the current owner is the offender, but if it accepts children as a\n // property, it may be the creator of the child that's responsible for\n // assigning it a key.\n\n " --> (1337:54-1338:3) " true;\n\t\t" +(2041:2-2041:6) " var" --> (1338:3-1338:7) "\tvar" +(2041:6-2041:19) " childOwner =" --> (1338:7-1338:20) " childOwner =" +(2041:19-2043:2) " '';\n\n " --> (1338:20-1339:0) " \"\";" +(2043:2-2043:6) " if " --> (1339:0-1339:7) "\n\t\t\tif " +(2043:6-2043:17) "(element &&" --> (1339:7-1339:18) "(element &&" +(2043:17-2043:25) " element" --> (1339:18-1339:26) " element" +(2043:25-2043:35) "._owner &&" --> (1339:26-1339:36) "._owner &&" +(2043:35-2043:43) " element" --> (1339:36-1339:44) " element" +(2043:43-2043:54) "._owner !==" --> (1339:44-1339:55) "._owner !==" +(2043:54-2043:72) " ReactCurrentOwner" --> (1339:55-1339:73) " ReactCurrentOwner" +(2043:72-2043:81) ".current)" --> (1339:73-1339:82) ".current)" +(2043:81-2045:4) " {\n // Give the component that originally created this child.\n " --> (1339:82-1340:0) " {" +(2045:4-2045:17) " childOwner =" --> (1340:0-1340:17) "\n\t\t\t\tchildOwner =" +(2045:17-2045:50) " \" It was passed a child from \" +" --> (1340:17-1340:50) " \" It was passed a child from \" +" +(2045:50-2045:67) " getComponentName" --> (1340:50-1340:67) " getComponentName" +(2045:67-2045:75) "(element" --> (1340:67-1340:75) "(element" +(2045:75-2045:82) "._owner" --> (1340:75-1340:82) "._owner" +(2045:82-2045:87) ".type" --> (1340:82-1340:87) ".type" +(2045:87-2045:90) ") +" --> (1340:87-1340:90) ") +" +(2045:90-2046:3) " \".\";\n " --> (1340:90-1341:3) " \".\";\n\t\t" +(2046:3-2048:2) "}\n\n " --> (1341:3-1342:3) "\t}\n\t\t" +(2048:2-2049:4) " {\n " --> (1342:3-1343:0) "\t{" +(2049:4-2049:36) " setCurrentlyValidatingElement$1" --> (1343:0-1343:36) "\n\t\t\t\tsetCurrentlyValidatingElement$1" +(2049:36-2049:44) "(element" --> (1343:36-1343:44) "(element" +(2049:44-2051:4) ");\n\n " --> (1343:44-1344:0) ");" +(2051:4-2051:10) " error" --> (1344:0-1344:10) "\n\t\t\t\terror" +(2051:10-2051:68) "('Each child in a list should have a unique \"key\" prop.' +" --> (1344:10-1344:70) "(\"Each child in a list should have a unique \\\"key\\\" prop.\" +" +(2051:68-2051:140) " '%s%s See https://reactjs.org/link/warning-keys for more information.'," --> (1344:70-1344:142) " \"%s%s See https://reactjs.org/link/warning-keys for more information.\"," +(2051:140-2051:167) " currentComponentErrorInfo," --> (1344:142-1344:169) " currentComponentErrorInfo," +(2051:167-2051:178) " childOwner" --> (1344:169-1344:180) " childOwner" +(2051:178-2053:4) ");\n\n " --> (1344:180-1345:0) ");" +(2053:4-2053:36) " setCurrentlyValidatingElement$1" --> (1345:0-1345:36) "\n\t\t\t\tsetCurrentlyValidatingElement$1" +(2053:36-2053:41) "(null" --> (1345:36-1345:41) "(null" +(2053:41-2054:3) ");\n " --> (1345:41-1346:3) ");\n\t\t" +(2054:3-2055:1) "}\n" --> (1346:3-1347:2) "\t}\n\t" +(2055:1-2067:0) "}\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\n\n" --> (1347:2-1348:2) "\t}\n\t" +(2067:0-2067:9) "\nfunction" --> (1348:2-1348:11) "\tfunction" +(2067:9-2067:27) " validateChildKeys" --> (1348:11-1348:29) " validateChildKeys" +(2067:27-2067:33) "(node," --> (1348:29-1348:35) "(node," +(2067:33-2067:45) " parentType)" --> (1348:35-1348:47) " parentType)" +(2067:45-2068:2) " {\n " --> (1348:47-1349:0) " {" +(2068:2-2068:13) " if (typeof" --> (1349:0-1349:14) "\n\t\t\tif (typeof" +(2068:13-2068:22) " node !==" --> (1349:14-1349:23) " node !==" +(2068:22-2068:32) " 'object')" --> (1349:23-1349:33) " \"object\")" +(2068:32-2069:4) " {\n " --> (1349:33-1350:0) " {" +(2069:4-2070:3) " return;\n " --> (1350:0-1351:3) "\n\t\t\t\treturn;\n\t\t" +(2070:3-2072:2) "}\n\n " --> (1351:3-1352:0) "\t}" +(2072:2-2072:6) " if " --> (1352:0-1352:7) "\n\t\t\tif " +(2072:6-2072:12) "(Array" --> (1352:7-1352:13) "(Array" +(2072:12-2072:20) ".isArray" --> (1352:13-1352:21) ".isArray" +(2072:20-2072:25) "(node" --> (1352:21-1352:26) "(node" +(2072:25-2072:27) "))" --> (1352:26-1352:28) "))" +(2072:27-2073:4) " {\n " --> (1352:28-1353:0) " {" +(2073:4-2073:9) " for " --> (1353:0-1353:9) "\n\t\t\t\tfor " +(2073:9-2073:13) "(var" --> (1353:9-1353:13) "(var" +(2073:13-2073:17) " i =" --> (1353:13-1353:17) " i =" +(2073:17-2073:20) " 0;" --> (1353:17-1353:20) " 0;" +(2073:20-2073:24) " i <" --> (1353:20-1353:24) " i <" +(2073:24-2073:29) " node" --> (1353:24-1353:29) " node" +(2073:29-2073:37) ".length;" --> (1353:29-1353:37) ".length;" +(2073:37-2073:42) " i++)" --> (1353:37-1353:42) " i++)" +(2073:42-2074:6) " {\n " --> (1353:42-1354:5) " {\n\t\t\t\t" +(2074:6-2074:10) " var" --> (1354:5-1354:9) "\tvar" +(2074:10-2074:18) " child =" --> (1354:9-1354:17) " child =" +(2074:18-2074:23) " node" --> (1354:17-1354:22) " node" +(2074:23-2076:6) "[i];\n\n " --> (1354:22-1355:0) "[i];" +(2076:6-2076:10) " if " --> (1355:0-1355:9) "\n\t\t\t\t\tif " +(2076:10-2076:25) "(isValidElement" --> (1355:9-1355:24) "(isValidElement" +(2076:25-2076:31) "(child" --> (1355:24-1355:30) "(child" +(2076:31-2076:33) "))" --> (1355:30-1355:32) "))" +(2076:33-2077:8) " {\n " --> (1355:32-1356:0) " {" +(2077:8-2077:28) " validateExplicitKey" --> (1356:0-1356:26) "\n\t\t\t\t\t\tvalidateExplicitKey" +(2077:28-2077:35) "(child," --> (1356:26-1356:33) "(child," +(2077:35-2077:46) " parentType" --> (1356:33-1356:44) " parentType" +(2077:46-2078:7) ");\n " --> (1356:44-1357:5) ");\n\t\t\t\t" +(2078:7-2079:5) "}\n " --> (1357:5-1358:4) "\t}\n\t\t\t" +(2079:5-2080:3) "}\n " --> (1358:4-1359:3) "\t}\n\t\t" +(2080:3-2080:13) "} else if " --> (1359:3-1359:14) "\t} else if " +(2080:13-2080:28) "(isValidElement" --> (1359:14-1359:29) "(isValidElement" +(2080:28-2080:33) "(node" --> (1359:29-1359:34) "(node" +(2080:33-2080:35) "))" --> (1359:34-1359:36) "))" +(2080:35-2082:4) " {\n // This element was passed in a valid location.\n " --> (1359:36-1360:0) " {" +(2082:4-2082:8) " if " --> (1360:0-1360:8) "\n\t\t\t\tif " +(2082:8-2082:13) "(node" --> (1360:8-1360:13) "(node" +(2082:13-2082:21) "._store)" --> (1360:13-1360:21) "._store)" +(2082:21-2083:6) " {\n " --> (1360:21-1361:0) " {" +(2083:6-2083:11) " node" --> (1361:0-1361:10) "\n\t\t\t\t\tnode" +(2083:11-2083:18) "._store" --> (1361:10-1361:17) "._store" +(2083:18-2083:30) ".validated =" --> (1361:17-1361:29) ".validated =" +(2083:30-2084:5) " true;\n " --> (1361:29-1362:4) " true;\n\t\t\t" +(2084:5-2085:3) "}\n " --> (1362:4-1363:3) "\t}\n\t\t" +(2085:3-2085:13) "} else if " --> (1363:3-1363:14) "\t} else if " +(2085:13-2085:19) "(node)" --> (1363:14-1363:20) "(node)" +(2085:19-2086:4) " {\n " --> (1363:20-1364:4) " {\n\t\t\t" +(2086:4-2086:8) " var" --> (1364:4-1364:8) "\tvar" +(2086:8-2086:21) " iteratorFn =" --> (1364:8-1364:21) " iteratorFn =" +(2086:21-2086:35) " getIteratorFn" --> (1364:21-1364:35) " getIteratorFn" +(2086:35-2086:40) "(node" --> (1364:35-1364:40) "(node" +(2086:40-2088:4) ");\n\n " --> (1364:40-1365:0) ");" +(2088:4-2088:15) " if (typeof" --> (1365:0-1365:15) "\n\t\t\t\tif (typeof" +(2088:15-2088:30) " iteratorFn ===" --> (1365:15-1365:30) " iteratorFn ===" +(2088:30-2088:42) " 'function')" --> (1365:30-1365:42) " \"function\")" +(2088:42-2091:6) " {\n // Entry iterators used to provide implicit keys,\n // but now we print a separate warning for them later.\n " --> (1365:42-1366:0) " {" +(2091:6-2091:10) " if " --> (1366:0-1366:9) "\n\t\t\t\t\tif " +(2091:10-2091:25) "(iteratorFn !==" --> (1366:9-1366:24) "(iteratorFn !==" +(2091:25-2091:30) " node" --> (1366:24-1366:29) " node" +(2091:30-2091:39) ".entries)" --> (1366:29-1366:38) ".entries)" +(2091:39-2092:8) " {\n " --> (1366:38-1367:6) " {\n\t\t\t\t\t" +(2092:8-2092:12) " var" --> (1367:6-1367:10) "\tvar" +(2092:12-2092:23) " iterator =" --> (1367:10-1367:21) " iterator =" +(2092:23-2092:34) " iteratorFn" --> (1367:21-1367:32) " iteratorFn" +(2092:34-2092:39) ".call" --> (1367:32-1367:37) ".call" +(2092:39-2092:44) "(node" --> (1367:37-1367:42) "(node" +(2092:44-2093:8) ");\n " --> (1367:42-1368:6) ");\n\t\t\t\t\t" +(2093:8-2093:12) " var" --> (1368:6-1368:10) "\tvar" +(2093:12-2095:8) " step;\n\n " --> (1368:10-1369:0) " step;" +(2095:8-2095:17) " while (!" --> (1369:0-1369:15) "\n\t\t\t\t\t\twhile (!" +(2095:17-2095:24) "(step =" --> (1369:15-1369:22) "(step =" +(2095:24-2095:33) " iterator" --> (1369:22-1369:31) " iterator" +(2095:33-2095:39) ".next(" --> (1369:31-1369:37) ".next(" +(2095:39-2095:41) "))" --> (1369:37-1369:39) "))" +(2095:41-2095:47) ".done)" --> (1369:39-1369:45) ".done)" +(2095:47-2096:10) " {\n " --> (1369:45-1370:0) " {" +(2096:10-2096:14) " if " --> (1370:0-1370:11) "\n\t\t\t\t\t\t\tif " +(2096:14-2096:29) "(isValidElement" --> (1370:11-1370:26) "(isValidElement" +(2096:29-2096:34) "(step" --> (1370:26-1370:31) "(step" +(2096:34-2096:40) ".value" --> (1370:31-1370:37) ".value" +(2096:40-2096:42) "))" --> (1370:37-1370:39) "))" +(2096:42-2097:12) " {\n " --> (1370:39-1371:0) " {" +(2097:12-2097:32) " validateExplicitKey" --> (1371:0-1371:28) "\n\t\t\t\t\t\t\t\tvalidateExplicitKey" +(2097:32-2097:37) "(step" --> (1371:28-1371:33) "(step" +(2097:37-2097:44) ".value," --> (1371:33-1371:40) ".value," +(2097:44-2097:55) " parentType" --> (1371:40-1371:51) " parentType" +(2097:55-2098:11) ");\n " --> (1371:51-1372:7) ");\n\t\t\t\t\t\t" +(2098:11-2099:9) "}\n " --> (1372:7-1373:6) "\t}\n\t\t\t\t\t" +(2099:9-2100:7) "}\n " --> (1373:6-1374:5) "\t}\n\t\t\t\t" +(2100:7-2101:5) "}\n " --> (1374:5-1375:4) "\t}\n\t\t\t" +(2101:5-2102:3) "}\n " --> (1375:4-1376:3) "\t}\n\t\t" +(2102:3-2103:1) "}\n" --> (1376:3-1377:2) "\t}\n\t" +(2103:1-2112:0) "}\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\n\n" --> (1377:2-1378:2) "\t}\n\t" +(2112:0-2112:9) "\nfunction" --> (1378:2-1378:11) "\tfunction" +(2112:9-2112:27) " validatePropTypes" --> (1378:11-1378:29) " validatePropTypes" +(2112:27-2112:36) "(element)" --> (1378:29-1378:38) "(element)" +(2112:36-2113:2) " {\n " --> (1378:38-1379:3) " {\n\t\t" +(2113:2-2114:4) " {\n " --> (1379:3-1380:4) "\t{\n\t\t\t" +(2114:4-2114:8) " var" --> (1380:4-1380:8) "\tvar" +(2114:8-2114:15) " type =" --> (1380:8-1380:15) " type =" +(2114:15-2114:23) " element" --> (1380:15-1380:23) " element" +(2114:23-2116:4) ".type;\n\n " --> (1380:23-1381:0) ".type;" +(2116:4-2116:8) " if " --> (1381:0-1381:8) "\n\t\t\t\tif " +(2116:8-2116:17) "(type ===" --> (1381:8-1381:17) "(type ===" +(2116:17-2116:25) " null ||" --> (1381:17-1381:25) " null ||" +(2116:25-2116:34) " type ===" --> (1381:25-1381:34) " type ===" +(2116:34-2116:54) " undefined || typeof" --> (1381:34-1381:54) " undefined || typeof" +(2116:54-2116:63) " type ===" --> (1381:54-1381:63) " type ===" +(2116:63-2116:73) " 'string')" --> (1381:63-1381:73) " \"string\")" +(2116:73-2117:6) " {\n " --> (1381:73-1382:0) " {" +(2117:6-2118:5) " return;\n " --> (1382:0-1383:4) "\n\t\t\t\t\treturn;\n\t\t\t" +(2118:5-2120:4) "}\n\n " --> (1383:4-1384:4) "\t}\n\t\t\t" +(2120:4-2120:8) " var" --> (1384:4-1384:8) "\tvar" +(2120:8-2122:4) " propTypes;\n\n " --> (1384:8-1385:0) " propTypes;" +(2122:4-2122:15) " if (typeof" --> (1385:0-1385:15) "\n\t\t\t\tif (typeof" +(2122:15-2122:24) " type ===" --> (1385:15-1385:24) " type ===" +(2122:24-2122:36) " 'function')" --> (1385:24-1385:36) " \"function\")" +(2122:36-2123:6) " {\n " --> (1385:36-1386:0) " {" +(2123:6-2123:18) " propTypes =" --> (1386:0-1386:17) "\n\t\t\t\t\tpropTypes =" +(2123:18-2123:23) " type" --> (1386:17-1386:22) " type" +(2123:23-2124:5) ".propTypes;\n " --> (1386:22-1387:4) ".propTypes;\n\t\t\t" +(2124:5-2124:22) "} else if (typeof" --> (1387:4-1387:22) "\t} else if (typeof" +(2124:22-2124:31) " type ===" --> (1387:22-1387:31) " type ===" +(2124:31-2124:44) " 'object' && " --> (1387:31-1387:44) " \"object\" && " +(2124:44-2124:49) "(type" --> (1387:44-1387:49) "(type" +(2124:49-2124:62) ".$$typeof ===" --> (1387:49-1387:62) ".$$typeof ===" +(2124:62-2126:4) " REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.\n // Inner props are checked in the reconciler.\n " --> (1387:62-1387:88) " REACT_FORWARD_REF_TYPE ||" +(2126:4-2126:9) " type" --> (1387:88-1387:93) " type" +(2126:9-2126:22) ".$$typeof ===" --> (1387:93-1387:106) ".$$typeof ===" +(2126:22-2126:40) " REACT_MEMO_TYPE))" --> (1387:106-1387:124) " REACT_MEMO_TYPE))" +(2126:40-2127:6) " {\n " --> (1387:124-1388:0) " {" +(2127:6-2127:18) " propTypes =" --> (1388:0-1388:17) "\n\t\t\t\t\tpropTypes =" +(2127:18-2127:23) " type" --> (1388:17-1388:22) " type" +(2127:23-2128:5) ".propTypes;\n " --> (1388:22-1389:4) ".propTypes;\n\t\t\t" +(2128:5-2128:11) "} else" --> (1389:4-1389:11) "\t} else" +(2128:11-2129:6) " {\n " --> (1389:11-1390:0) " {" +(2129:6-2130:5) " return;\n " --> (1390:0-1391:4) "\n\t\t\t\t\treturn;\n\t\t\t" +(2130:5-2132:4) "}\n\n " --> (1391:4-1392:0) "\t}" +(2132:4-2132:8) " if " --> (1392:0-1392:8) "\n\t\t\t\tif " +(2132:8-2132:19) "(propTypes)" --> (1392:8-1392:19) "(propTypes)" +(2132:19-2134:6) " {\n // Intentionally inside to avoid triggering lazy initializers:\n " --> (1392:19-1393:5) " {\n\t\t\t\t" +(2134:6-2134:10) " var" --> (1393:5-1393:9) "\tvar" +(2134:10-2134:17) " name =" --> (1393:9-1393:16) " name =" +(2134:17-2134:34) " getComponentName" --> (1393:16-1393:33) " getComponentName" +(2134:34-2134:39) "(type" --> (1393:33-1393:38) "(type" +(2134:39-2135:6) ");\n " --> (1393:38-1394:0) ");" +(2135:6-2135:21) " checkPropTypes" --> (1394:0-1394:20) "\n\t\t\t\t\tcheckPropTypes" +(2135:21-2135:32) "(propTypes," --> (1394:20-1394:31) "(propTypes," +(2135:32-2135:40) " element" --> (1394:31-1394:39) " element" +(2135:40-2135:47) ".props," --> (1394:39-1394:46) ".props," +(2135:47-2135:55) " 'prop'," --> (1394:46-1394:54) " \"prop\"," +(2135:55-2135:61) " name," --> (1394:54-1394:60) " name," +(2135:61-2135:69) " element" --> (1394:60-1394:68) " element" +(2135:69-2136:5) ");\n " --> (1394:68-1395:4) ");\n\t\t\t" +(2136:5-2136:15) "} else if " --> (1395:4-1395:15) "\t} else if " +(2136:15-2136:20) "(type" --> (1395:15-1395:20) "(type" +(2136:20-2136:34) ".PropTypes !==" --> (1395:20-1395:34) ".PropTypes !==" +(2136:34-2136:48) " undefined && " --> (1395:34-1395:48) " undefined && " +(2136:48-2136:79) "!propTypesMisspellWarningShown)" --> (1395:48-1395:79) "!propTypesMisspellWarningShown)" +(2136:79-2137:6) " {\n " --> (1395:79-1396:0) " {" +(2137:6-2137:38) " propTypesMisspellWarningShown =" --> (1396:0-1396:37) "\n\t\t\t\t\tpropTypesMisspellWarningShown =" +(2137:38-2139:6) " true; // Intentionally inside to avoid triggering lazy initializers:\n\n " --> (1396:37-1397:5) " true;\n\t\t\t\t" +(2139:6-2139:10) " var" --> (1397:5-1397:9) "\tvar" +(2139:10-2139:18) " _name =" --> (1397:9-1397:17) " _name =" +(2139:18-2139:35) " getComponentName" --> (1397:17-1397:34) " getComponentName" +(2139:35-2139:40) "(type" --> (1397:34-1397:39) "(type" +(2139:40-2141:6) ");\n\n " --> (1397:39-1398:0) ");" +(2141:6-2141:12) " error" --> (1398:0-1398:11) "\n\t\t\t\t\terror" +(2141:12-2141:115) "('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?'," --> (1398:11-1398:114) "(\"Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?\"," +(2141:115-2141:124) " _name ||" --> (1398:114-1398:123) " _name ||" +(2141:124-2141:134) " 'Unknown'" --> (1398:123-1398:133) " \"Unknown\"" +(2141:134-2142:5) ");\n " --> (1398:133-1399:4) ");\n\t\t\t" +(2142:5-2144:4) "}\n\n " --> (1399:4-1400:0) "\t}" +(2144:4-2144:15) " if (typeof" --> (1400:0-1400:15) "\n\t\t\t\tif (typeof" +(2144:15-2144:20) " type" --> (1400:15-1400:20) " type" +(2144:20-2144:40) ".getDefaultProps ===" --> (1400:20-1400:40) ".getDefaultProps ===" +(2144:40-2144:55) " 'function' && " --> (1400:40-1400:55) " \"function\" && " +(2144:55-2144:60) "!type" --> (1400:55-1400:60) "!type" +(2144:60-2144:76) ".getDefaultProps" --> (1400:60-1400:76) ".getDefaultProps" +(2144:76-2144:98) ".isReactClassApproved)" --> (1400:76-1400:98) ".isReactClassApproved)" +(2144:98-2145:6) " {\n " --> (1400:98-1401:0) " {" +(2145:6-2145:12) " error" --> (1401:0-1401:11) "\n\t\t\t\t\terror" +(2145:12-2145:75) "('getDefaultProps is only used on classic React.createClass ' +" --> (1401:11-1401:74) "(\"getDefaultProps is only used on classic React.createClass \" +" +(2145:75-2145:142) " 'definitions. Use a static property named `defaultProps` instead.'" --> (1401:74-1401:141) " \"definitions. Use a static property named `defaultProps` instead.\"" +(2145:142-2146:5) ");\n " --> (1401:141-1402:4) ");\n\t\t\t" +(2146:5-2147:3) "}\n " --> (1402:4-1403:3) "\t}\n\t\t" +(2147:3-2148:1) "}\n" --> (1403:3-1404:2) "\t}\n\t" +(2148:1-2155:0) "}\n/**\n * Given a fragment, validate that it can only be provided with fragment props\n * @param {ReactElement} fragment\n */\n\n" --> (1404:2-1405:2) "\t}\n\t" +(2155:0-2155:9) "\nfunction" --> (1405:2-1405:11) "\tfunction" +(2155:9-2155:31) " validateFragmentProps" --> (1405:11-1405:33) " validateFragmentProps" +(2155:31-2155:41) "(fragment)" --> (1405:33-1405:43) "(fragment)" +(2155:41-2156:2) " {\n " --> (1405:43-1406:3) " {\n\t\t" +(2156:2-2157:4) " {\n " --> (1406:3-1407:4) "\t{\n\t\t\t" +(2157:4-2157:8) " var" --> (1407:4-1407:8) "\tvar" +(2157:8-2157:15) " keys =" --> (1407:8-1407:15) " keys =" +(2157:15-2157:22) " Object" --> (1407:15-1407:22) " Object" +(2157:22-2157:27) ".keys" --> (1407:22-1407:27) ".keys" +(2157:27-2157:36) "(fragment" --> (1407:27-1407:36) "(fragment" +(2157:36-2157:42) ".props" --> (1407:36-1407:42) ".props" +(2157:42-2159:4) ");\n\n " --> (1407:42-1408:0) ");" +(2159:4-2159:9) " for " --> (1408:0-1408:9) "\n\t\t\t\tfor " +(2159:9-2159:13) "(var" --> (1408:9-1408:13) "(var" +(2159:13-2159:17) " i =" --> (1408:13-1408:17) " i =" +(2159:17-2159:20) " 0;" --> (1408:17-1408:20) " 0;" +(2159:20-2159:24) " i <" --> (1408:20-1408:24) " i <" +(2159:24-2159:29) " keys" --> (1408:24-1408:29) " keys" +(2159:29-2159:37) ".length;" --> (1408:29-1408:37) ".length;" +(2159:37-2159:42) " i++)" --> (1408:37-1408:42) " i++)" +(2159:42-2160:6) " {\n " --> (1408:42-1409:5) " {\n\t\t\t\t" +(2160:6-2160:10) " var" --> (1409:5-1409:9) "\tvar" +(2160:10-2160:16) " key =" --> (1409:9-1409:15) " key =" +(2160:16-2160:21) " keys" --> (1409:15-1409:20) " keys" +(2160:21-2162:6) "[i];\n\n " --> (1409:20-1410:0) "[i];" +(2162:6-2162:10) " if " --> (1410:0-1410:9) "\n\t\t\t\t\tif " +(2162:10-2162:18) "(key !==" --> (1410:9-1410:17) "(key !==" +(2162:18-2162:32) " 'children' &&" --> (1410:17-1410:31) " \"children\" &&" +(2162:32-2162:40) " key !==" --> (1410:31-1410:39) " key !==" +(2162:40-2162:47) " 'key')" --> (1410:39-1410:46) " \"key\")" +(2162:47-2163:8) " {\n " --> (1410:46-1411:0) " {" +(2163:8-2163:40) " setCurrentlyValidatingElement$1" --> (1411:0-1411:38) "\n\t\t\t\t\t\tsetCurrentlyValidatingElement$1" +(2163:40-2163:49) "(fragment" --> (1411:38-1411:47) "(fragment" +(2163:49-2165:8) ");\n\n " --> (1411:47-1412:0) ");" +(2165:8-2165:14) " error" --> (1412:0-1412:12) "\n\t\t\t\t\t\terror" +(2165:14-2165:67) "('Invalid prop `%s` supplied to `React.Fragment`. ' +" --> (1412:12-1412:65) "(\"Invalid prop `%s` supplied to `React.Fragment`. \" +" +(2165:67-2165:127) " 'React.Fragment can only have `key` and `children` props.'," --> (1412:65-1412:125) " \"React.Fragment can only have `key` and `children` props.\"," +(2165:127-2165:131) " key" --> (1412:125-1412:129) " key" +(2165:131-2167:8) ");\n\n " --> (1412:129-1413:0) ");" +(2167:8-2167:40) " setCurrentlyValidatingElement$1" --> (1413:0-1413:38) "\n\t\t\t\t\t\tsetCurrentlyValidatingElement$1" +(2167:40-2167:45) "(null" --> (1413:38-1413:43) "(null" +(2167:45-2168:8) ");\n " --> (1413:43-1414:0) ");" +(2168:8-2169:7) " break;\n " --> (1414:0-1415:5) "\n\t\t\t\t\t\tbreak;\n\t\t\t\t" +(2169:7-2170:5) "}\n " --> (1415:5-1416:4) "\t}\n\t\t\t" +(2170:5-2172:4) "}\n\n " --> (1416:4-1417:0) "\t}" +(2172:4-2172:8) " if " --> (1417:0-1417:8) "\n\t\t\t\tif " +(2172:8-2172:17) "(fragment" --> (1417:8-1417:17) "(fragment" +(2172:17-2172:25) ".ref !==" --> (1417:17-1417:25) ".ref !==" +(2172:25-2172:31) " null)" --> (1417:25-1417:31) " null)" +(2172:31-2173:6) " {\n " --> (1417:31-1418:0) " {" +(2173:6-2173:38) " setCurrentlyValidatingElement$1" --> (1418:0-1418:37) "\n\t\t\t\t\tsetCurrentlyValidatingElement$1" +(2173:38-2173:47) "(fragment" --> (1418:37-1418:46) "(fragment" +(2173:47-2175:6) ");\n\n " --> (1418:46-1419:0) ");" +(2175:6-2175:12) " error" --> (1419:0-1419:11) "\n\t\t\t\t\terror" +(2175:12-2175:68) "('Invalid attribute `ref` supplied to `React.Fragment`.'" --> (1419:11-1419:67) "(\"Invalid attribute `ref` supplied to `React.Fragment`.\"" +(2175:68-2177:6) ");\n\n " --> (1419:67-1420:0) ");" +(2177:6-2177:38) " setCurrentlyValidatingElement$1" --> (1420:0-1420:37) "\n\t\t\t\t\tsetCurrentlyValidatingElement$1" +(2177:38-2177:43) "(null" --> (1420:37-1420:42) "(null" +(2177:43-2178:5) ");\n " --> (1420:42-1421:4) ");\n\t\t\t" +(2178:5-2179:3) "}\n " --> (1421:4-1422:3) "\t}\n\t\t" +(2179:3-2180:1) "}\n" --> (1422:3-1423:2) "\t}\n\t" +(2180:1-2181:0) "}" --> (1423:2-1424:2) "\t}\n\t" +(2181:0-2181:9) "\nfunction" --> (1424:2-1424:11) "\tfunction" +(2181:9-2181:37) " createElementWithValidation" --> (1424:11-1424:39) " createElementWithValidation" +(2181:37-2181:43) "(type," --> (1424:39-1424:45) "(type," +(2181:43-2181:50) " props," --> (1424:45-1424:52) " props," +(2181:50-2181:60) " children)" --> (1424:52-1424:62) " children)" +(2181:60-2182:2) " {\n " --> (1424:62-1425:3) " {\n\t\t" +(2182:2-2182:6) " var" --> (1425:3-1425:7) "\tvar" +(2182:6-2182:18) " validType =" --> (1425:7-1425:19) " validType =" +(2182:18-2182:37) " isValidElementType" --> (1425:19-1425:38) " isValidElementType" +(2182:37-2182:42) "(type" --> (1425:38-1425:43) "(type" +(2182:42-2185:2) "); // We warn in this case but don't throw. We expect the element creation to\n // succeed and there will likely be errors in render.\n\n " --> (1425:43-1426:0) ");" +(2185:2-2185:7) " if (" --> (1426:0-1426:8) "\n\t\t\tif (" +(2185:7-2185:18) "!validType)" --> (1426:8-1426:19) "!validType)" +(2185:18-2186:4) " {\n " --> (1426:19-1427:4) " {\n\t\t\t" +(2186:4-2186:8) " var" --> (1427:4-1427:8) "\tvar" +(2186:8-2186:15) " info =" --> (1427:8-1427:15) " info =" +(2186:15-2188:4) " '';\n\n " --> (1427:15-1428:0) " \"\";" +(2188:4-2188:8) " if " --> (1428:0-1428:8) "\n\t\t\t\tif " +(2188:8-2188:17) "(type ===" --> (1428:8-1428:17) "(type ===" +(2188:17-2188:37) " undefined || typeof" --> (1428:17-1428:37) " undefined || typeof" +(2188:37-2188:46) " type ===" --> (1428:37-1428:46) " type ===" +(2188:46-2188:58) " 'object' &&" --> (1428:46-1428:58) " \"object\" &&" +(2188:58-2188:67) " type !==" --> (1428:58-1428:67) " type !==" +(2188:67-2188:75) " null &&" --> (1428:67-1428:75) " null &&" +(2188:75-2188:82) " Object" --> (1428:75-1428:82) " Object" +(2188:82-2188:87) ".keys" --> (1428:82-1428:87) ".keys" +(2188:87-2188:92) "(type" --> (1428:87-1428:92) "(type" +(2188:92-2188:93) ")" --> (1428:92-1428:93) ")" +(2188:93-2188:104) ".length ===" --> (1428:93-1428:104) ".length ===" +(2188:104-2188:107) " 0)" --> (1428:104-1428:107) " 0)" +(2188:107-2189:6) " {\n " --> (1428:107-1429:0) " {" +(2189:6-2189:14) " info +=" --> (1429:0-1429:13) "\n\t\t\t\t\tinfo +=" +(2189:14-2189:77) " ' You likely forgot to export your component from the file ' +" --> (1429:13-1429:76) " \" You likely forgot to export your component from the file \" +" +(2189:77-2190:5) " \"it's defined in, or you might have mixed up default and named imports.\";\n " --> (1429:76-1430:4) " \"it's defined in, or you might have mixed up default and named imports.\";\n\t\t\t" +(2190:5-2192:4) "}\n\n " --> (1430:4-1431:4) "\t}\n\t\t\t" +(2192:4-2192:8) " var" --> (1431:4-1431:8) "\tvar" +(2192:8-2192:21) " sourceInfo =" --> (1431:8-1431:21) " sourceInfo =" +(2192:21-2192:56) " getSourceInfoErrorAddendumForProps" --> (1431:21-1431:56) " getSourceInfoErrorAddendumForProps" +(2192:56-2192:62) "(props" --> (1431:56-1431:62) "(props" +(2192:62-2194:4) ");\n\n " --> (1431:62-1432:0) ");" +(2194:4-2194:8) " if " --> (1432:0-1432:8) "\n\t\t\t\tif " +(2194:8-2194:20) "(sourceInfo)" --> (1432:8-1432:20) "(sourceInfo)" +(2194:20-2195:6) " {\n " --> (1432:20-1433:0) " {" +(2195:6-2195:14) " info +=" --> (1433:0-1433:13) "\n\t\t\t\t\tinfo +=" +(2195:14-2196:5) " sourceInfo;\n " --> (1433:13-1434:4) " sourceInfo;\n\t\t\t" +(2196:5-2196:11) "} else" --> (1434:4-1434:11) "\t} else" +(2196:11-2197:6) " {\n " --> (1434:11-1435:0) " {" +(2197:6-2197:14) " info +=" --> (1435:0-1435:13) "\n\t\t\t\t\tinfo +=" +(2197:14-2197:43) " getDeclarationErrorAddendum(" --> (1435:13-1435:42) " getDeclarationErrorAddendum(" +(2197:43-2198:5) ");\n " --> (1435:42-1436:4) ");\n\t\t\t" +(2198:5-2200:4) "}\n\n " --> (1436:4-1437:4) "\t}\n\t\t\t" +(2200:4-2200:8) " var" --> (1437:4-1437:8) "\tvar" +(2200:8-2202:4) " typeString;\n\n " --> (1437:8-1438:0) " typeString;" +(2202:4-2202:8) " if " --> (1438:0-1438:8) "\n\t\t\t\tif " +(2202:8-2202:17) "(type ===" --> (1438:8-1438:17) "(type ===" +(2202:17-2202:23) " null)" --> (1438:17-1438:23) " null)" +(2202:23-2203:6) " {\n " --> (1438:23-1439:0) " {" +(2203:6-2203:19) " typeString =" --> (1439:0-1439:18) "\n\t\t\t\t\ttypeString =" +(2203:19-2204:5) " 'null';\n " --> (1439:18-1440:4) " \"null\";\n\t\t\t" +(2204:5-2204:15) "} else if " --> (1440:4-1440:15) "\t} else if " +(2204:15-2204:21) "(Array" --> (1440:15-1440:21) "(Array" +(2204:21-2204:29) ".isArray" --> (1440:21-1440:29) ".isArray" +(2204:29-2204:34) "(type" --> (1440:29-1440:34) "(type" +(2204:34-2204:36) "))" --> (1440:34-1440:36) "))" +(2204:36-2205:6) " {\n " --> (1440:36-1441:0) " {" +(2205:6-2205:19) " typeString =" --> (1441:0-1441:18) "\n\t\t\t\t\ttypeString =" +(2205:19-2206:5) " 'array';\n " --> (1441:18-1442:4) " \"array\";\n\t\t\t" +(2206:5-2206:15) "} else if " --> (1442:4-1442:15) "\t} else if " +(2206:15-2206:24) "(type !==" --> (1442:15-1442:24) "(type !==" +(2206:24-2206:37) " undefined &&" --> (1442:24-1442:37) " undefined &&" +(2206:37-2206:42) " type" --> (1442:37-1442:42) " type" +(2206:42-2206:55) ".$$typeof ===" --> (1442:42-1442:55) ".$$typeof ===" +(2206:55-2206:75) " REACT_ELEMENT_TYPE)" --> (1442:55-1442:75) " REACT_ELEMENT_TYPE)" +(2206:75-2207:6) " {\n " --> (1442:75-1443:0) " {" +(2207:6-2207:19) " typeString =" --> (1443:0-1443:18) "\n\t\t\t\t\ttypeString =" +(2207:19-2207:26) " \"<\" + " --> (1443:18-1443:25) " \"<\" + " +(2207:26-2207:43) "(getComponentName" --> (1443:25-1443:42) "(getComponentName" +(2207:43-2207:48) "(type" --> (1443:42-1443:47) "(type" +(2207:48-2207:53) ".type" --> (1443:47-1443:52) ".type" +(2207:53-2207:57) ") ||" --> (1443:52-1443:56) ") ||" +(2207:57-2207:70) " 'Unknown') +" --> (1443:56-1443:69) " \"Unknown\") +" +(2207:70-2208:6) " \" />\";\n " --> (1443:69-1444:0) " \" />\";" +(2208:6-2208:13) " info =" --> (1444:0-1444:12) "\n\t\t\t\t\tinfo =" +(2208:13-2209:5) " ' Did you accidentally export a JSX literal instead of a component?';\n " --> (1444:12-1445:4) " \" Did you accidentally export a JSX literal instead of a component?\";\n\t\t\t" +(2209:5-2209:11) "} else" --> (1445:4-1445:11) "\t} else" +(2209:11-2210:6) " {\n " --> (1445:11-1446:0) " {" +(2210:6-2210:26) " typeString = typeof" --> (1446:0-1446:25) "\n\t\t\t\t\ttypeString = typeof" +(2210:26-2211:5) " type;\n " --> (1446:25-1447:4) " type;\n\t\t\t" +(2211:5-2213:4) "}\n\n " --> (1447:4-1448:4) "\t}\n\t\t\t" +(2213:4-2214:6) " {\n " --> (1448:4-1449:0) "\t{" +(2214:6-2214:12) " error" --> (1449:0-1449:11) "\n\t\t\t\t\terror" +(2214:12-2214:80) "('React.createElement: type is invalid -- expected a string (for ' +" --> (1449:11-1449:79) "(\"React.createElement: type is invalid -- expected a string (for \" +" +(2214:80-2214:141) " 'built-in components) or a class/function (for composite ' +" --> (1449:79-1449:140) " \"built-in components) or a class/function (for composite \" +" +(2214:141-2214:171) " 'components) but got: %s.%s'," --> (1449:140-1449:170) " \"components) but got: %s.%s\"," +(2214:171-2214:183) " typeString," --> (1449:170-1449:182) " typeString," +(2214:183-2214:188) " info" --> (1449:182-1449:187) " info" +(2214:188-2215:5) ");\n " --> (1449:187-1450:4) ");\n\t\t\t" +(2215:5-2216:3) "}\n " --> (1450:4-1451:3) "\t}\n\t\t" +(2216:3-2218:2) "}\n\n " --> (1451:3-1452:3) "\t}\n\t\t" +(2218:2-2218:6) " var" --> (1452:3-1452:7) "\tvar" +(2218:6-2218:16) " element =" --> (1452:7-1452:17) " element =" +(2218:16-2218:30) " createElement" --> (1452:17-1452:31) " createElement" +(2218:30-2218:36) ".apply" --> (1452:31-1452:37) ".apply" +(2218:36-2218:42) "(this," --> (1452:37-1452:43) "(this," +(2218:42-2218:52) " arguments" --> (1452:43-1452:53) " arguments" +(2218:52-2221:2) "); // The result can be nullish if a mock or a custom function is used.\n // TODO: Drop this when these are no longer allowed as the type argument.\n\n " --> (1452:53-1453:0) ");" +(2221:2-2221:6) " if " --> (1453:0-1453:7) "\n\t\t\tif " +(2221:6-2221:17) "(element ==" --> (1453:7-1453:18) "(element ==" +(2221:17-2221:23) " null)" --> (1453:18-1453:24) " null)" +(2221:23-2222:4) " {\n " --> (1453:24-1454:0) " {" +(2222:4-2222:11) " return" --> (1454:0-1454:11) "\n\t\t\t\treturn" +(2222:11-2223:3) " element;\n " --> (1454:11-1455:3) " element;\n\t\t" +(2223:3-2230:2) "} // Skip key warning if the type isn't valid since our key validation logic\n // doesn't expect a non-string/function type and can throw confusing errors.\n // We don't want exception behavior to differ between dev and prod.\n // (Rendering will throw with a helpful message and as soon as the type is\n // fixed, the key warnings will appear.)\n\n\n " --> (1455:3-1456:0) "\t}" +(2230:2-2230:6) " if " --> (1456:0-1456:7) "\n\t\t\tif " +(2230:6-2230:17) "(validType)" --> (1456:7-1456:18) "(validType)" +(2230:17-2231:4) " {\n " --> (1456:18-1457:0) " {" +(2231:4-2231:9) " for " --> (1457:0-1457:9) "\n\t\t\t\tfor " +(2231:9-2231:13) "(var" --> (1457:9-1457:13) "(var" +(2231:13-2231:17) " i =" --> (1457:13-1457:17) " i =" +(2231:17-2231:20) " 2;" --> (1457:17-1457:20) " 2;" +(2231:20-2231:24) " i <" --> (1457:20-1457:24) " i <" +(2231:24-2231:34) " arguments" --> (1457:24-1457:34) " arguments" +(2231:34-2231:42) ".length;" --> (1457:34-1457:42) ".length;" +(2231:42-2231:47) " i++)" --> (1457:42-1457:47) " i++)" +(2231:47-2232:6) " {\n " --> (1457:47-1458:0) " {" +(2232:6-2232:24) " validateChildKeys" --> (1458:0-1458:23) "\n\t\t\t\t\tvalidateChildKeys" +(2232:24-2232:34) "(arguments" --> (1458:23-1458:33) "(arguments" +(2232:34-2232:38) "[i]," --> (1458:33-1458:37) "[i]," +(2232:38-2232:43) " type" --> (1458:37-1458:42) " type" +(2232:43-2233:5) ");\n " --> (1458:42-1459:4) ");\n\t\t\t" +(2233:5-2234:3) "}\n " --> (1459:4-1460:3) "\t}\n\t\t" +(2234:3-2236:2) "}\n\n " --> (1460:3-1461:0) "\t}" +(2236:2-2236:6) " if " --> (1461:0-1461:7) "\n\t\t\tif " +(2236:6-2236:15) "(type ===" --> (1461:7-1461:16) "(type ===" +(2236:15-2236:23) " exports" --> (1461:16-1461:24) " exports" +(2236:23-2236:33) ".Fragment)" --> (1461:24-1461:34) ".Fragment)" +(2236:33-2237:4) " {\n " --> (1461:34-1462:0) " {" +(2237:4-2237:26) " validateFragmentProps" --> (1462:0-1462:26) "\n\t\t\t\tvalidateFragmentProps" +(2237:26-2237:34) "(element" --> (1462:26-1462:34) "(element" +(2237:34-2238:3) ");\n " --> (1462:34-1463:3) ");\n\t\t" +(2238:3-2238:9) "} else" --> (1463:3-1463:10) "\t} else" +(2238:9-2239:4) " {\n " --> (1463:10-1464:0) " {" +(2239:4-2239:22) " validatePropTypes" --> (1464:0-1464:22) "\n\t\t\t\tvalidatePropTypes" +(2239:22-2239:30) "(element" --> (1464:22-1464:30) "(element" +(2239:30-2240:3) ");\n " --> (1464:30-1465:3) ");\n\t\t" +(2240:3-2242:2) "}\n\n " --> (1465:3-1466:0) "\t}" +(2242:2-2242:9) " return" --> (1466:0-1466:10) "\n\t\t\treturn" +(2242:9-2243:1) " element;\n" --> (1466:10-1467:2) " element;\n\t" +(2243:1-2244:0) "}" --> (1467:2-1468:2) "\t}\n\t" +(2244:0-2244:4) "\nvar" --> (1468:2-1468:6) "\tvar" +(2244:4-2244:42) " didWarnAboutDeprecatedCreateFactory =" --> (1468:6-1468:44) " didWarnAboutDeprecatedCreateFactory =" +(2244:42-2245:0) " false;" --> (1468:44-1469:2) " false;\n\t" +(2245:0-2245:9) "\nfunction" --> (1469:2-1469:11) "\tfunction" +(2245:9-2245:37) " createFactoryWithValidation" --> (1469:11-1469:39) " createFactoryWithValidation" +(2245:37-2245:43) "(type)" --> (1469:39-1469:45) "(type)" +(2245:43-2246:2) " {\n " --> (1469:45-1470:3) " {\n\t\t" +(2246:2-2246:6) " var" --> (1470:3-1470:7) "\tvar" +(2246:6-2246:25) " validatedFactory =" --> (1470:7-1470:26) " validatedFactory =" +(2246:25-2246:53) " createElementWithValidation" --> (1470:26-1470:54) " createElementWithValidation" +(2246:53-2246:58) ".bind" --> (1470:54-1470:59) ".bind" +(2246:58-2246:64) "(null," --> (1470:59-1470:65) "(null," +(2246:64-2246:69) " type" --> (1470:65-1470:70) " type" +(2246:69-2247:2) ");\n " --> (1470:70-1471:0) ");" +(2247:2-2247:19) " validatedFactory" --> (1471:0-1471:20) "\n\t\t\tvalidatedFactory" +(2247:19-2247:26) ".type =" --> (1471:20-1471:27) ".type =" +(2247:26-2249:2) " type;\n\n " --> (1471:27-1472:3) " type;\n\t\t" +(2249:2-2250:4) " {\n " --> (1472:3-1473:0) "\t{" +(2250:4-2250:9) " if (" --> (1473:0-1473:9) "\n\t\t\t\tif (" +(2250:9-2250:46) "!didWarnAboutDeprecatedCreateFactory)" --> (1473:9-1473:46) "!didWarnAboutDeprecatedCreateFactory)" +(2250:46-2251:6) " {\n " --> (1473:46-1474:0) " {" +(2251:6-2251:44) " didWarnAboutDeprecatedCreateFactory =" --> (1474:0-1474:43) "\n\t\t\t\t\tdidWarnAboutDeprecatedCreateFactory =" +(2251:44-2253:6) " true;\n\n " --> (1474:43-1475:0) " true;" +(2253:6-2253:11) " warn" --> (1475:0-1475:10) "\n\t\t\t\t\twarn" +(2253:11-2253:75) "('React.createFactory() is deprecated and will be removed in ' +" --> (1475:10-1475:74) "(\"React.createFactory() is deprecated and will be removed in \" +" +(2253:75-2253:123) " 'a future major release. Consider using JSX ' +" --> (1475:74-1475:122) " \"a future major release. Consider using JSX \" +" +(2253:123-2253:172) " 'or use React.createElement() directly instead.'" --> (1475:122-1475:171) " \"or use React.createElement() directly instead.\"" +(2253:172-2254:5) ");\n " --> (1475:171-1476:4) ");\n\t\t\t" +(2254:5-2257:4) "} // Legacy hook: remove it\n\n\n " --> (1476:4-1477:0) "\t}" +(2257:4-2257:11) " Object" --> (1477:0-1477:11) "\n\t\t\t\tObject" +(2257:11-2257:26) ".defineProperty" --> (1477:11-1477:26) ".defineProperty" +(2257:26-2257:44) "(validatedFactory," --> (1477:26-1477:44) "(validatedFactory," +(2257:44-2257:52) " 'type'," --> (1477:44-1477:52) " \"type\"," +(2257:52-2258:6) " {\n " --> (1477:52-1478:5) " {\n\t\t\t\t" +(2258:6-2258:18) " enumerable:" --> (1478:5-1478:17) "\tenumerable:" +(2258:18-2259:6) " false,\n " --> (1478:17-1479:5) " false,\n\t\t\t\t" +(2259:6-2259:11) " get:" --> (1479:5-1479:10) "\tget:" +(2259:11-2259:23) " function ()" --> (1479:10-1479:21) " function()" +(2259:23-2260:8) " {\n " --> (1479:21-1480:0) " {" +(2260:8-2260:13) " warn" --> (1480:0-1480:11) "\n\t\t\t\t\t\twarn" +(2260:13-2260:72) "('Factory.type is deprecated. Access the class directly ' +" --> (1480:11-1480:70) "(\"Factory.type is deprecated. Access the class directly \" +" +(2260:72-2260:110) " 'before passing it to createFactory.'" --> (1480:70-1480:108) " \"before passing it to createFactory.\"" +(2260:110-2262:8) ");\n\n " --> (1480:108-1481:0) ");" +(2262:8-2262:15) " Object" --> (1481:0-1481:13) "\n\t\t\t\t\t\tObject" +(2262:15-2262:30) ".defineProperty" --> (1481:13-1481:28) ".defineProperty" +(2262:30-2262:36) "(this," --> (1481:28-1481:34) "(this," +(2262:36-2262:44) " 'type'," --> (1481:34-1481:42) " \"type\"," +(2262:44-2263:10) " {\n " --> (1481:42-1482:7) " {\n\t\t\t\t\t\t" +(2263:10-2263:17) " value:" --> (1482:7-1482:14) "\tvalue:" +(2263:17-2264:9) " type\n " --> (1482:14-1483:6) " type\n\t\t\t\t\t" +(2264:9-2264:10) "}" --> (1483:6-1483:8) "\t}" +(2264:10-2265:8) ");\n " --> (1483:8-1484:0) ");" +(2265:8-2265:15) " return" --> (1484:0-1484:13) "\n\t\t\t\t\t\treturn" +(2265:15-2266:7) " type;\n " --> (1484:13-1485:5) " type;\n\t\t\t\t" +(2266:7-2267:5) "}\n " --> (1485:5-1486:4) "\t}\n\t\t\t" +(2267:5-2267:6) "}" --> (1486:4-1486:6) "\t}" +(2267:6-2268:3) ");\n " --> (1486:6-1487:3) ");\n\t\t" +(2268:3-2270:2) "}\n\n " --> (1487:3-1488:0) "\t}" +(2270:2-2270:9) " return" --> (1488:0-1488:10) "\n\t\t\treturn" +(2270:9-2271:1) " validatedFactory;\n" --> (1488:10-1489:2) " validatedFactory;\n\t" +(2271:1-2272:0) "}" --> (1489:2-1490:2) "\t}\n\t" +(2272:0-2272:9) "\nfunction" --> (1490:2-1490:11) "\tfunction" +(2272:9-2272:36) " cloneElementWithValidation" --> (1490:11-1490:38) " cloneElementWithValidation" +(2272:36-2272:45) "(element," --> (1490:38-1490:47) "(element," +(2272:45-2272:52) " props," --> (1490:47-1490:54) " props," +(2272:52-2272:62) " children)" --> (1490:54-1490:64) " children)" +(2272:62-2273:2) " {\n " --> (1490:64-1491:3) " {\n\t\t" +(2273:2-2273:6) " var" --> (1491:3-1491:7) "\tvar" +(2273:6-2273:19) " newElement =" --> (1491:7-1491:20) " newElement =" +(2273:19-2273:32) " cloneElement" --> (1491:20-1491:33) " cloneElement" +(2273:32-2273:38) ".apply" --> (1491:33-1491:39) ".apply" +(2273:38-2273:44) "(this," --> (1491:39-1491:45) "(this," +(2273:44-2273:54) " arguments" --> (1491:45-1491:55) " arguments" +(2273:54-2275:2) ");\n\n " --> (1491:55-1492:0) ");" +(2275:2-2275:7) " for " --> (1492:0-1492:8) "\n\t\t\tfor " +(2275:7-2275:11) "(var" --> (1492:8-1492:12) "(var" +(2275:11-2275:15) " i =" --> (1492:12-1492:16) " i =" +(2275:15-2275:18) " 2;" --> (1492:16-1492:19) " 2;" +(2275:18-2275:22) " i <" --> (1492:19-1492:23) " i <" +(2275:22-2275:32) " arguments" --> (1492:23-1492:33) " arguments" +(2275:32-2275:40) ".length;" --> (1492:33-1492:41) ".length;" +(2275:40-2275:45) " i++)" --> (1492:41-1492:46) " i++)" +(2275:45-2276:4) " {\n " --> (1492:46-1493:0) " {" +(2276:4-2276:22) " validateChildKeys" --> (1493:0-1493:22) "\n\t\t\t\tvalidateChildKeys" +(2276:22-2276:32) "(arguments" --> (1493:22-1493:32) "(arguments" +(2276:32-2276:36) "[i]," --> (1493:32-1493:36) "[i]," +(2276:36-2276:47) " newElement" --> (1493:36-1493:47) " newElement" +(2276:47-2276:52) ".type" --> (1493:47-1493:52) ".type" +(2276:52-2277:3) ");\n " --> (1493:52-1494:3) ");\n\t\t" +(2277:3-2279:2) "}\n\n " --> (1494:3-1495:0) "\t}" +(2279:2-2279:20) " validatePropTypes" --> (1495:0-1495:21) "\n\t\t\tvalidatePropTypes" +(2279:20-2279:31) "(newElement" --> (1495:21-1495:32) "(newElement" +(2279:31-2280:2) ");\n " --> (1495:32-1496:0) ");" +(2280:2-2280:9) " return" --> (1496:0-1496:10) "\n\t\t\treturn" +(2280:9-2281:1) " newElement;\n" --> (1496:10-1497:2) " newElement;\n\t" +(2281:1-2283:0) "}\n" --> (1497:2-1498:2) "\t}\n\t" +(2283:0-2285:2) "\n{\n\n " --> (1498:2-1499:0) "\t{" +(2285:2-2285:6) " try" --> (1499:0-1499:7) "\n\t\t\ttry" +(2285:6-2286:4) " {\n " --> (1499:7-1500:4) " {\n\t\t\t" +(2286:4-2286:8) " var" --> (1500:4-1500:8) "\tvar" +(2286:8-2286:23) " frozenObject =" --> (1500:8-1500:23) " frozenObject =" +(2286:23-2286:30) " Object" --> (1500:23-1500:30) " Object" +(2286:30-2286:37) ".freeze" --> (1500:30-1500:37) ".freeze" +(2286:37-2286:39) "({" --> (1500:37-1500:38) "(" +(2286:39-2286:40) "}" --> (1500:38-1500:40) "{}" +(2286:40-2289:4) ");\n /* eslint-disable no-new */\n\n " --> (1500:40-1501:0) ");" +(2289:4-2289:8) " new" --> (1501:0-1501:8) "\n\t\t\t\tnew" +(2289:8-2289:12) " Map" --> (1501:8-1501:12) " Map" +(2289:12-2289:13) "(" --> (1501:12-1501:13) "(" +(2289:13-2289:14) "[" --> (1501:13-1501:14) "[" +(2289:14-2289:28) "[frozenObject," --> (1501:14-1501:28) "[frozenObject," +(2289:28-2289:33) " null" --> (1501:28-1501:33) " null" +(2289:33-2289:34) "]" --> (1501:33-1501:34) "]" +(2289:34-2290:4) "]);\n " --> (1501:34-1502:0) "]);" +(2290:4-2290:8) " new" --> (1502:0-1502:8) "\n\t\t\t\tnew" +(2290:8-2290:12) " Set" --> (1502:8-1502:12) " Set" +(2290:12-2290:13) "(" --> (1502:12-1502:13) "(" +(2290:13-2290:26) "[frozenObject" --> (1502:13-1502:26) "[frozenObject" +(2290:26-2292:3) "]);\n /* eslint-enable no-new */\n " --> (1502:26-1503:3) "]);\n\t\t" +(2292:3-2292:11) "} catch " --> (1503:3-1503:12) "\t} catch " +(2292:11-2292:14) "(e)" --> (1503:12-1503:15) "(e)" +(2292:14-2293:3) " {\n " --> (1503:15-1503:16) " " +(2293:3-2294:1) "}\n" --> (1503:16-1504:2) "{}\n\t" +(2294:1-2296:0) "}\n" --> (1504:2-1505:2) "\t}\n\t" +(2296:0-2296:4) "\nvar" --> (1505:2-1505:6) "\tvar" +(2296:4-2296:23) " createElement$1 = " --> (1505:6-1505:24) " createElement$1 =" +(2296:23-2297:0) " createElementWithValidation ;" --> (1505:24-1506:2) " createElementWithValidation;\n\t" +(2297:0-2297:4) "\nvar" --> (1506:2-1506:6) "\tvar" +(2297:4-2297:22) " cloneElement$1 = " --> (1506:6-1506:23) " cloneElement$1 =" +(2297:22-2298:0) " cloneElementWithValidation ;" --> (1506:23-1507:2) " cloneElementWithValidation;\n\t" +(2298:0-2298:4) "\nvar" --> (1507:2-1507:6) "\tvar" +(2298:4-2298:21) " createFactory = " --> (1507:6-1507:22) " createFactory =" +(2298:21-2299:0) " createFactoryWithValidation ;" --> (1507:22-1508:2) " createFactoryWithValidation;\n\t" +(2299:0-2299:4) "\nvar" --> (1508:2-1508:6) "\tvar" +(2299:4-2299:15) " Children =" --> (1508:6-1508:17) " Children =" +(2299:15-2300:2) " {\n " --> (1508:17-1509:3) " {\n\t\t" +(2300:2-2300:7) " map:" --> (1509:3-1509:8) "\tmap:" +(2300:7-2301:2) " mapChildren,\n " --> (1509:8-1510:3) " mapChildren,\n\t\t" +(2301:2-2301:11) " forEach:" --> (1510:3-1510:12) "\tforEach:" +(2301:11-2302:2) " forEachChildren,\n " --> (1510:12-1511:3) " forEachChildren,\n\t\t" +(2302:2-2302:9) " count:" --> (1511:3-1511:10) "\tcount:" +(2302:9-2303:11) " countChildren,\n toArray:" --> (1511:10-1512:3) " countChildren,\n\t\t" +(2303:11-2304:2) " toArray,\n " --> (1512:3-1513:3) "\ttoArray,\n\t\t" +(2304:2-2304:8) " only:" --> (1513:3-1513:9) "\tonly:" +(2304:8-2305:1) " onlyChild\n" --> (1513:9-1514:2) " onlyChild\n\t" +(2305:1-2307:0) "};\n" --> (1514:2-1515:0) "\t};" +(2307:0-2307:8) "\nexports" --> (1515:0-1515:10) "\n\t\texports" +(2307:8-2307:19) ".Children =" --> (1515:10-1515:21) ".Children =" +(2307:19-2308:0) " Children;" --> (1515:21-1516:0) " Children;" +(2308:0-2308:8) "\nexports" --> (1516:0-1516:10) "\n\t\texports" +(2308:8-2308:20) ".Component =" --> (1516:10-1516:22) ".Component =" +(2308:20-2309:0) " Component;" --> (1516:22-1517:0) " Component;" +(2309:0-2309:8) "\nexports" --> (1517:0-1517:10) "\n\t\texports" +(2309:8-2309:24) ".PureComponent =" --> (1517:10-1517:26) ".PureComponent =" +(2309:24-2310:0) " PureComponent;" --> (1517:26-1518:0) " PureComponent;" +(2310:0-2310:8) "\nexports" --> (1518:0-1518:10) "\n\t\texports" +(2310:8-2310:61) ".__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =" --> (1518:10-1518:63) ".__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =" +(2310:61-2311:0) " ReactSharedInternals;" --> (1518:63-1519:0) " ReactSharedInternals;" +(2311:0-2311:8) "\nexports" --> (1519:0-1519:10) "\n\t\texports" +(2311:8-2311:23) ".cloneElement =" --> (1519:10-1519:25) ".cloneElement =" +(2311:23-2312:0) " cloneElement$1;" --> (1519:25-1520:0) " cloneElement$1;" +(2312:0-2312:8) "\nexports" --> (1520:0-1520:10) "\n\t\texports" +(2312:8-2312:24) ".createContext =" --> (1520:10-1520:26) ".createContext =" +(2312:24-2313:0) " createContext;" --> (1520:26-1521:0) " createContext;" +(2313:0-2313:8) "\nexports" --> (1521:0-1521:10) "\n\t\texports" +(2313:8-2313:24) ".createElement =" --> (1521:10-1521:26) ".createElement =" +(2313:24-2314:0) " createElement$1;" --> (1521:26-1522:0) " createElement$1;" +(2314:0-2314:8) "\nexports" --> (1522:0-1522:10) "\n\t\texports" +(2314:8-2314:24) ".createFactory =" --> (1522:10-1522:26) ".createFactory =" +(2314:24-2315:0) " createFactory;" --> (1522:26-1523:0) " createFactory;" +(2315:0-2315:8) "\nexports" --> (1523:0-1523:10) "\n\t\texports" +(2315:8-2315:20) ".createRef =" --> (1523:10-1523:22) ".createRef =" +(2315:20-2316:0) " createRef;" --> (1523:22-1524:0) " createRef;" +(2316:0-2316:8) "\nexports" --> (1524:0-1524:10) "\n\t\texports" +(2316:8-2316:21) ".forwardRef =" --> (1524:10-1524:23) ".forwardRef =" +(2316:21-2317:0) " forwardRef;" --> (1524:23-1525:0) " forwardRef;" +(2317:0-2317:8) "\nexports" --> (1525:0-1525:10) "\n\t\texports" +(2317:8-2317:25) ".isValidElement =" --> (1525:10-1525:27) ".isValidElement =" +(2317:25-2318:0) " isValidElement;" --> (1525:27-1526:0) " isValidElement;" +(2318:0-2318:8) "\nexports" --> (1526:0-1526:10) "\n\t\texports" +(2318:8-2318:15) ".lazy =" --> (1526:10-1526:17) ".lazy =" +(2318:15-2319:0) " lazy;" --> (1526:17-1527:0) " lazy;" +(2319:0-2319:8) "\nexports" --> (1527:0-1527:10) "\n\t\texports" +(2319:8-2319:15) ".memo =" --> (1527:10-1527:17) ".memo =" +(2319:15-2320:0) " memo;" --> (1527:17-1528:0) " memo;" +(2320:0-2320:8) "\nexports" --> (1528:0-1528:10) "\n\t\texports" +(2320:8-2320:22) ".useCallback =" --> (1528:10-1528:24) ".useCallback =" +(2320:22-2321:0) " useCallback;" --> (1528:24-1529:0) " useCallback;" +(2321:0-2321:8) "\nexports" --> (1529:0-1529:10) "\n\t\texports" +(2321:8-2321:21) ".useContext =" --> (1529:10-1529:23) ".useContext =" +(2321:21-2322:0) " useContext;" --> (1529:23-1530:0) " useContext;" +(2322:0-2322:8) "\nexports" --> (1530:0-1530:10) "\n\t\texports" +(2322:8-2322:24) ".useDebugValue =" --> (1530:10-1530:26) ".useDebugValue =" +(2322:24-2323:0) " useDebugValue;" --> (1530:26-1531:0) " useDebugValue;" +(2323:0-2323:8) "\nexports" --> (1531:0-1531:10) "\n\t\texports" +(2323:8-2323:20) ".useEffect =" --> (1531:10-1531:22) ".useEffect =" +(2323:20-2324:0) " useEffect;" --> (1531:22-1532:0) " useEffect;" +(2324:0-2324:8) "\nexports" --> (1532:0-1532:10) "\n\t\texports" +(2324:8-2324:30) ".useImperativeHandle =" --> (1532:10-1532:32) ".useImperativeHandle =" +(2324:30-2325:0) " useImperativeHandle;" --> (1532:32-1533:0) " useImperativeHandle;" +(2325:0-2325:8) "\nexports" --> (1533:0-1533:10) "\n\t\texports" +(2325:8-2325:26) ".useLayoutEffect =" --> (1533:10-1533:28) ".useLayoutEffect =" +(2325:26-2326:0) " useLayoutEffect;" --> (1533:28-1534:0) " useLayoutEffect;" +(2326:0-2326:8) "\nexports" --> (1534:0-1534:10) "\n\t\texports" +(2326:8-2326:18) ".useMemo =" --> (1534:10-1534:20) ".useMemo =" +(2326:18-2327:0) " useMemo;" --> (1534:20-1535:0) " useMemo;" +(2327:0-2327:8) "\nexports" --> (1535:0-1535:10) "\n\t\texports" +(2327:8-2327:21) ".useReducer =" --> (1535:10-1535:23) ".useReducer =" +(2327:21-2328:0) " useReducer;" --> (1535:23-1536:0) " useReducer;" +(2328:0-2328:8) "\nexports" --> (1536:0-1536:10) "\n\t\texports" +(2328:8-2328:17) ".useRef =" --> (1536:10-1536:19) ".useRef =" +(2328:17-2329:0) " useRef;" --> (1536:19-1537:0) " useRef;" +(2329:0-2329:8) "\nexports" --> (1537:0-1537:10) "\n\t\texports" +(2329:8-2329:19) ".useState =" --> (1537:10-1537:21) ".useState =" +(2329:19-2330:0) " useState;" --> (1537:21-1538:0) " useState;" +(2330:0-2330:8) "\nexports" --> (1538:0-1538:10) "\n\t\texports" +(2330:8-2330:18) ".version =" --> (1538:10-1538:20) ".version =" +(2330:18-2331:3) " ReactVersion;\n " --> (1538:20-1539:1) " ReactVersion;\n" +(2331:3-2331:6) "})(" --> (1539:1-1539:5) "\t})(" +(2331:6-2332:1) ");\n" --> (1539:5-1540:0) ");" +(2332:1-2333:1) "}\n" --> (1540:0-1541:1) "\n}\n" diff --git a/tasks/transform_conformance/babel.snap.md b/tasks/transform_conformance/babel.snap.md index 64b54a6beac84..70f71ba404ba8 100644 --- a/tasks/transform_conformance/babel.snap.md +++ b/tasks/transform_conformance/babel.snap.md @@ -2258,37 +2258,13 @@ rebuilt : ScopeId(0): ["C"] x Output mismatch * exports/issue-9916-1/input.ts -Bindings mismatch: -after transform: ScopeId(0): ["PromiseRejectCb", "PromiseResolveCb", "a"] -rebuilt : ScopeId(0): ["a"] -Scope children mismatch: -after transform: ScopeId(0): [ScopeId(1), ScopeId(2)] -rebuilt : ScopeId(0): [] -Unresolved references mismatch: -after transform: ["PromiseLike"] -rebuilt : [] +x Output mismatch * exports/issue-9916-2/input.ts -Bindings mismatch: -after transform: ScopeId(0): ["PromiseRejectCb", "PromiseResolveCb"] -rebuilt : ScopeId(0): [] -Scope children mismatch: -after transform: ScopeId(0): [ScopeId(1), ScopeId(2)] -rebuilt : ScopeId(0): [] -Unresolved references mismatch: -after transform: ["PromiseLike"] -rebuilt : [] +x Output mismatch * exports/issue-9916-3/input.ts -Bindings mismatch: -after transform: ScopeId(0): ["PromiseRejectCb", "PromiseResolveCb", "a"] -rebuilt : ScopeId(0): ["a"] -Scope children mismatch: -after transform: ScopeId(0): [ScopeId(1), ScopeId(2)] -rebuilt : ScopeId(0): [] -Unresolved references mismatch: -after transform: ["PromiseLike"] -rebuilt : [] +x Output mismatch * exports/type-only-export-specifier-1/input.ts Symbol reference IDs mismatch: @@ -2489,23 +2465,7 @@ after transform: SymbolId(2): [ReferenceId(4), ReferenceId(6)] rebuilt : SymbolId(1): [ReferenceId(1)] * namespace/alias/input.ts -Missing SymbolId: b -Missing SymbolId: AliasModule -Bindings mismatch: -after transform: ScopeId(0): ["AliasModule", "LongNameModule", "b", "babel", "bar", "baz", "node", "some", "str"] -rebuilt : ScopeId(0): ["AliasModule", "b", "babel", "bar", "baz", "node", "some", "str"] -Scope children mismatch: -after transform: ScopeId(0): [ScopeId(1)] -rebuilt : ScopeId(0): [] -Reference symbol mismatch: -after transform: ReferenceId(3): Some("AliasModule") -rebuilt : ReferenceId(2): Some("AliasModule") -Reference symbol mismatch: -after transform: ReferenceId(4): Some("AliasModule") -rebuilt : ReferenceId(3): Some("AliasModule") -Unresolved reference IDs mismatch for "LongNameModule": -after transform: [ReferenceId(1), ReferenceId(5)] -rebuilt : [ReferenceId(1)] +x Output mismatch * namespace/ambient-module-nested/input.ts Ambient modules cannot be nested in other modules or namespaces. diff --git a/tasks/transform_conformance/src/test_case.rs b/tasks/transform_conformance/src/test_case.rs index 15bb97973ea9a..f4ab8a18d44dc 100644 --- a/tasks/transform_conformance/src/test_case.rs +++ b/tasks/transform_conformance/src/test_case.rs @@ -6,7 +6,7 @@ use std::{ use cow_utils::CowUtils; use oxc::{ allocator::Allocator, - codegen::CodeGenerator, + codegen::{CodeGenerator, CommentOptions}, diagnostics::{Error, NamedSource, OxcDiagnostic}, parser::Parser, span::{SourceType, VALID_EXTENSIONS}, @@ -299,7 +299,10 @@ impl TestCase for ConformanceTestCase { |output| { // Get expected code by parsing the source text, so we can get the same code generated result. let ret = Parser::new(&allocator, &output, source_type).parse(); - CodeGenerator::new().build(&ret.program).source_text + CodeGenerator::new() + .enable_comment(&output, ret.trivias, CommentOptions::default()) + .build(&ret.program) + .source_text }, );