From 5fc75a38477e9f810bc4ee8aba4c741425fe2342 Mon Sep 17 00:00:00 2001 From: Tobias Koppers Date: Thu, 1 Aug 2024 09:56:31 +0200 Subject: [PATCH 1/3] Skip unreachable code when early return can be statically analysed (#8890) ### Description * tracks early returns and their conditions * replaces unreachable code with `"TURBOPACK unreachable"` * finds hoisted declarations in unreachable code and keeps them ### Testing Instructions --- .../src/analyzer/graph.rs | 410 +- .../turbopack-ecmascript/src/analyzer/mod.rs | 23 + .../turbopack-ecmascript/src/path_visitor.rs | 2 + .../src/references/mod.rs | 50 +- .../src/references/unreachable.rs | 258 +- crates/turbopack-ecmascript/src/utils.rs | 15 +- .../graph/array-map/graph-effects.snapshot | 452 +- .../graph/array-map/resolved-effects.snapshot | 28 +- .../graph/arrow/graph-effects.snapshot | 415 +- .../graph/arrow/resolved-effects.snapshot | 31 + .../graph/class_super/graph-effects.snapshot | 122 +- .../conditional-import/graph-effects.snapshot | 776 +- .../graph-explained.snapshot | 4 + .../graph/conditional-import/graph.snapshot | 32 + .../graph/conditional-import/input.js | 12 + .../resolved-effects.snapshot | 9 + .../resolved-explained.snapshot | 4 + .../graph/default-args/graph-effects.snapshot | 113 +- .../default-args/resolved-effects.snapshot | 7 + .../graph/early-return/graph-effects.snapshot | 4086 +++ .../early-return/graph-explained.snapshot | 23 + .../graph/early-return/graph.snapshot | 222 + .../analyzer/graph/early-return/input.js | 81 + .../early-return/resolved-effects.snapshot | 203 + .../early-return/resolved-explained.snapshot | 27 + .../esbuild-reduced/graph-effects.snapshot | 106 +- .../esbuild-reduced/resolved-effects.snapshot | 26 +- .../graph/esbuild/graph-effects.snapshot | 10343 +++---- .../graph/esbuild/resolved-effects.snapshot | 210 +- .../graph/fn-array-2/graph-effects.snapshot | 32 + .../fn-array-2/resolved-effects.snapshot | 4 + .../graph/fn-array/graph-effects.snapshot | 32 + .../graph/fn-array/resolved-effects.snapshot | 4 + .../graph/iife/graph-effects.snapshot | 104 +- .../graph/md5-reduced/graph-effects.snapshot | 290 +- .../md5-reduced/resolved-effects.snapshot | 72 +- .../graph/md5/resolved-effects.snapshot | 232 +- .../graph/md5_2/graph-effects.snapshot | 2574 +- .../graph/md5_2/resolved-effects.snapshot | 44 +- .../graph/nested-args/graph-effects.snapshot | 470 +- .../nested-args/resolved-effects.snapshot | 42 +- .../graph/op-assign/graph-effects.snapshot | 366 +- .../graph/op-assign/resolved-effects.snapshot | 20 +- .../graph/pack-2236/graph-effects.snapshot | 128 +- .../graph/pack-2682/graph-effects.snapshot | 339 +- .../graph/pack-2682/resolved-effects.snapshot | 6 +- .../graph/peg/resolved-effects.snapshot | 4700 +-- .../resolved-effects.snapshot | 23972 +++++++++------- .../require-context/graph-effects.snapshot | 566 +- .../require-context/resolved-effects.snapshot | 28 +- .../graph/unreachable/graph-effects.snapshot | 1763 ++ .../unreachable/graph-explained.snapshot | 29 + .../analyzer/graph/unreachable/graph.snapshot | 214 + .../tests/analyzer/graph/unreachable/input.js | 69 + .../unreachable/resolved-effects.snapshot | 121 + .../unreachable/resolved-explained.snapshot | 29 + .../comptime/input/index.js | 6 +- ..._comptime_define_input_index_49857f.js.map | 2 +- .../comptime/early-return/input/index.js | 2 + .../comptime/early-return/input/module.js | 207 + ...ot_comptime_early-return_input_99b3d5._.js | 191 + ...omptime_early-return_input_99b3d5._.js.map | 9 + ...omptime_early-return_input_index_c9750a.js | 6 + ...ime_early-return_input_index_c9750a.js.map | 5 + 64 files changed, 34904 insertions(+), 19864 deletions(-) create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/arrow/resolved-effects.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-effects.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-explained.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/early-return/input.js create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-effects.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-explained.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-effects.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-explained.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/input.js create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-effects.snapshot create mode 100644 crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-explained.snapshot create mode 100644 crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js create mode 100644 crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js create mode 100644 crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js create mode 100644 crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js.map create mode 100644 crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js create mode 100644 crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js.map diff --git a/crates/turbopack-ecmascript/src/analyzer/graph.rs b/crates/turbopack-ecmascript/src/analyzer/graph.rs index 8105ae870289f..976569b7dbb57 100644 --- a/crates/turbopack-ecmascript/src/analyzer/graph.rs +++ b/crates/turbopack-ecmascript/src/analyzer/graph.rs @@ -16,13 +16,15 @@ use turbo_tasks::{RcStr, Vc}; use turbopack_core::source::Source; use super::{ConstantNumber, ConstantValue, ImportMap, JsValue, ObjectPart, WellKnownFunctionKind}; -use crate::{analyzer::is_unresolved, utils::unparen}; +use crate::{ + analyzer::is_unresolved, + utils::{unparen, AstPathRange}, +}; -#[derive(Debug, Clone, Default)] +#[derive(Debug, Clone)] pub struct EffectsBlock { pub effects: Vec, - /// The ast path to the block or expression. - pub ast_path: Vec, + pub range: AstPathRange, } impl EffectsBlock { @@ -35,11 +37,19 @@ impl EffectsBlock { pub enum ConditionalKind { /// The blocks of an `if` statement without an `else` block. If { then: EffectsBlock }, - /// The blocks of an `if ... else` statement. + /// The blocks of an `if ... else` or `if { ... return ... } ...` statement. IfElse { then: EffectsBlock, r#else: EffectsBlock, }, + /// The blocks of an `if ... else` statement. + Else { r#else: EffectsBlock }, + /// The blocks of an `if { ... return ... } else { ... } ...` or `if { ... } + /// else { ... return ... } ...` statement. + IfElseMultiple { + then: Vec, + r#else: Vec, + }, /// The expressions on the right side of the `?:` operator. Ternary { then: EffectsBlock, @@ -57,8 +67,12 @@ impl ConditionalKind { /// Normalizes all contained values. pub fn normalize(&mut self) { match self { - ConditionalKind::If { then, .. } => { - for effect in &mut then.effects { + ConditionalKind::If { then: block } + | ConditionalKind::Else { r#else: block } + | ConditionalKind::And { expr: block, .. } + | ConditionalKind::Or { expr: block, .. } + | ConditionalKind::NullishCoalescing { expr: block, .. } => { + for effect in &mut block.effects { effect.normalize(); } } @@ -71,11 +85,11 @@ impl ConditionalKind { effect.normalize(); } } - ConditionalKind::And { expr, .. } - | ConditionalKind::Or { expr, .. } - | ConditionalKind::NullishCoalescing { expr, .. } => { - for effect in &mut expr.effects { - effect.normalize(); + ConditionalKind::IfElseMultiple { then, r#else, .. } => { + for block in then.iter_mut().chain(r#else.iter_mut()) { + for effect in &mut block.effects { + effect.normalize(); + } } } } @@ -172,6 +186,8 @@ pub enum Effect { span: Span, in_try: bool, }, + /// Unreachable code, e.g. after a `return` statement. + Unreachable { start_ast_path: Vec }, } impl Effect { @@ -211,6 +227,7 @@ impl Effect { Effect::Url { input, .. } => { input.normalize(); } + Effect::Unreachable { .. } => {} } } } @@ -246,6 +263,8 @@ pub fn create_graph(m: &Program, eval_context: &EvalContext) -> VarGraph { data: &mut graph, eval_context, effects: Default::default(), + hoisted_effects: Default::default(), + early_return_stack: Default::default(), var_decl_kind: Default::default(), current_value: Default::default(), cur_fn_return_values: Default::default(), @@ -647,10 +666,33 @@ impl EvalContext { } } +enum EarlyReturn { + Always { + prev_effects: Vec, + start_ast_path: Vec, + }, + Conditional { + prev_effects: Vec, + start_ast_path: Vec, + + condition: JsValue, + then: Option, + r#else: Option, + /// The ast path to the condition. + condition_ast_path: Vec, + span: Span, + in_try: bool, + + early_return_condition_value: bool, + }, +} + struct Analyzer<'a> { data: &'a mut VarGraph, effects: Vec, + hoisted_effects: Vec, + early_return_stack: Vec, eval_context: &'a EvalContext, @@ -1008,6 +1050,80 @@ impl Analyzer<'_> { _ => JsValue::alternatives(values), }) } + + /// Ends a conditional block. All early returns are integrated into the + /// effects. Returns true if the whole block always early returns. + fn end_early_return_block(&mut self) -> bool { + let mut always_returns = false; + while let Some(early_return) = self.early_return_stack.pop() { + match early_return { + EarlyReturn::Always { + prev_effects, + start_ast_path, + } => { + self.effects = prev_effects; + self.effects.push(Effect::Unreachable { start_ast_path }); + always_returns = true; + } + EarlyReturn::Conditional { + prev_effects, + start_ast_path, + condition, + then, + r#else, + condition_ast_path, + span, + in_try, + early_return_condition_value, + } => { + let block = EffectsBlock { + effects: take(&mut self.effects), + range: AstPathRange::StartAfter(start_ast_path), + }; + self.effects = prev_effects; + let kind = match (then, r#else, early_return_condition_value) { + (None, None, false) => ConditionalKind::If { then: block }, + (None, None, true) => ConditionalKind::IfElseMultiple { + then: vec![block], + r#else: vec![], + }, + (Some(then), None, false) => ConditionalKind::IfElseMultiple { + then: vec![then, block], + r#else: vec![], + }, + (Some(then), None, true) => ConditionalKind::IfElse { + then, + r#else: block, + }, + (Some(then), Some(r#else), false) => ConditionalKind::IfElseMultiple { + then: vec![then, block], + r#else: vec![r#else], + }, + (Some(then), Some(r#else), true) => ConditionalKind::IfElseMultiple { + then: vec![then], + r#else: vec![r#else, block], + }, + (None, Some(r#else), false) => ConditionalKind::IfElse { + then: block, + r#else, + }, + (None, Some(r#else), true) => ConditionalKind::IfElseMultiple { + then: vec![], + r#else: vec![r#else, block], + }, + }; + self.effects.push(Effect::Conditional { + condition, + kind: Box::new(kind), + ast_path: condition_ast_path, + span, + in_try, + }) + } + } + } + always_returns + } } impl VisitAstPath for Analyzer<'_> { @@ -1166,7 +1282,7 @@ impl VisitAstPath for Analyzer<'_> { value, EffectsBlock { effects, - ast_path: path, + range: AstPathRange::Exact(path), }, ) } else { @@ -1295,6 +1411,7 @@ impl VisitAstPath for Analyzer<'_> { self.cur_fn_ident = decl.function.span.lo.0; decl.visit_children_with_path(self, ast_path); let return_value = self.take_return_values(); + self.hoisted_effects.append(&mut self.effects); self.add_value( decl.ident.to_id(), @@ -1579,6 +1696,11 @@ impl VisitAstPath for Analyzer<'_> { values.push(return_value); } + + self.early_return_stack.push(EarlyReturn::Always { + prev_effects: take(&mut self.effects), + start_ast_path: as_parent_path(ast_path), + }); } fn visit_ident<'ast: 'r, 'r>( @@ -1643,6 +1765,8 @@ impl VisitAstPath for Analyzer<'_> { ) { self.effects = take(&mut self.data.effects); program.visit_children_with_path(self, ast_path); + self.end_early_return_block(); + self.effects.append(&mut self.hoisted_effects); self.data.effects = take(&mut self.effects); } @@ -1664,7 +1788,7 @@ impl VisitAstPath for Analyzer<'_> { expr.cons.visit_with_path(self, &mut ast_path); EffectsBlock { effects: take(&mut self.effects), - ast_path: as_parent_path(&ast_path), + range: AstPathRange::Exact(as_parent_path(&ast_path)), } }; let r#else = { @@ -1673,7 +1797,7 @@ impl VisitAstPath for Analyzer<'_> { expr.alt.visit_with_path(self, &mut ast_path); EffectsBlock { effects: take(&mut self.effects), - ast_path: as_parent_path(&ast_path), + range: AstPathRange::Exact(as_parent_path(&ast_path)), } }; self.effects = prev_effects; @@ -1698,56 +1822,235 @@ impl VisitAstPath for Analyzer<'_> { stmt.test.visit_with_path(self, &mut ast_path); } let prev_effects = take(&mut self.effects); + let prev_early_return_stack = take(&mut self.early_return_stack); + let then_returning; let then = { let mut ast_path = ast_path.with_guard(AstParentNodeRef::IfStmt(stmt, IfStmtField::Cons)); stmt.cons.visit_with_path(self, &mut ast_path); + then_returning = self.end_early_return_block(); EffectsBlock { effects: take(&mut self.effects), - ast_path: as_parent_path(&ast_path), + range: AstPathRange::Exact(as_parent_path(&ast_path)), } }; - let r#else = stmt - .alt - .as_ref() - .map(|alt| { - let mut ast_path = - ast_path.with_guard(AstParentNodeRef::IfStmt(stmt, IfStmtField::Alt)); - alt.visit_with_path(self, &mut ast_path); - EffectsBlock { - effects: take(&mut self.effects), - ast_path: as_parent_path(&ast_path), - } - }) - .unwrap_or_default(); + let mut else_returning = false; + let r#else = stmt.alt.as_ref().map(|alt| { + let mut ast_path = + ast_path.with_guard(AstParentNodeRef::IfStmt(stmt, IfStmtField::Alt)); + alt.visit_with_path(self, &mut ast_path); + else_returning = self.end_early_return_block(); + EffectsBlock { + effects: take(&mut self.effects), + range: AstPathRange::Exact(as_parent_path(&ast_path)), + } + }); + self.early_return_stack = prev_early_return_stack; self.effects = prev_effects; - match (!then.is_empty(), !r#else.is_empty()) { - (true, false) => { - self.add_conditional_effect( - &stmt.test, - ast_path, - AstParentKind::IfStmt(IfStmtField::Test), - stmt.span(), - ConditionalKind::If { then }, - ); + self.add_conditional_if_effect_with_early_return( + &stmt.test, + ast_path, + AstParentKind::IfStmt(IfStmtField::Test), + stmt.span(), + (!then.is_empty()).then_some(then), + r#else.and_then(|block| (!block.is_empty()).then_some(block)), + then_returning, + else_returning, + ); + } + + fn visit_try_stmt<'ast: 'r, 'r>( + &mut self, + stmt: &'ast TryStmt, + ast_path: &mut swc_core::ecma::visit::AstNodePath<'r>, + ) { + let prev_effects = take(&mut self.effects); + let prev_early_return_stack = take(&mut self.early_return_stack); + let mut block = { + let mut ast_path = + ast_path.with_guard(AstParentNodeRef::TryStmt(stmt, TryStmtField::Block)); + stmt.block.visit_with_path(self, &mut ast_path); + self.end_early_return_block(); + take(&mut self.effects) + }; + let mut handler = if let Some(handler) = stmt.handler.as_ref() { + let mut ast_path = + ast_path.with_guard(AstParentNodeRef::TryStmt(stmt, TryStmtField::Handler)); + handler.visit_with_path(self, &mut ast_path); + self.end_early_return_block(); + take(&mut self.effects) + } else { + vec![] + }; + self.early_return_stack = prev_early_return_stack; + self.effects = prev_effects; + self.effects.append(&mut block); + self.effects.append(&mut handler); + if let Some(finalizer) = stmt.finalizer.as_ref() { + let mut ast_path = + ast_path.with_guard(AstParentNodeRef::TryStmt(stmt, TryStmtField::Finalizer)); + finalizer.visit_with_path(self, &mut ast_path); + }; + } + + fn visit_switch_case<'ast: 'r, 'r>( + &mut self, + case: &'ast SwitchCase, + ast_path: &mut swc_core::ecma::visit::AstNodePath<'r>, + ) { + let prev_effects = take(&mut self.effects); + let prev_early_return_stack = take(&mut self.early_return_stack); + case.visit_children_with_path(self, ast_path); + self.end_early_return_block(); + let mut effects = take(&mut self.effects); + self.early_return_stack = prev_early_return_stack; + self.effects = prev_effects; + self.effects.append(&mut effects); + } + + fn visit_block_stmt<'ast: 'r, 'r>( + &mut self, + n: &'ast BlockStmt, + ast_path: &mut swc_core::ecma::visit::AstNodePath<'r>, + ) { + let block_type = if ast_path.len() < 2 { + Some(false) + } else if matches!( + &ast_path[ast_path.len() - 2..], + [ + AstParentNodeRef::IfStmt(_, IfStmtField::Cons), + AstParentNodeRef::Stmt(_, StmtField::Block) + ] | [ + AstParentNodeRef::IfStmt(_, IfStmtField::Alt), + AstParentNodeRef::Stmt(_, StmtField::Block) + ] | [_, AstParentNodeRef::TryStmt(_, TryStmtField::Block,)] + | [ + AstParentNodeRef::TryStmt(_, TryStmtField::Handler), + AstParentNodeRef::CatchClause(_, CatchClauseField::Body) + ] + ) { + None + } else if matches!( + &ast_path[ast_path.len() - 2..], + [_, AstParentNodeRef::Function(_, FunctionField::Body)] + | [ + AstParentNodeRef::ArrowExpr(_, ArrowExprField::Body), + AstParentNodeRef::BlockStmtOrExpr(_, BlockStmtOrExprField::BlockStmt) + ] + | [_, AstParentNodeRef::GetterProp(_, GetterPropField::Body)] + | [_, AstParentNodeRef::SetterProp(_, SetterPropField::Body)] + | [_, AstParentNodeRef::Constructor(_, ConstructorField::Body)] + ) { + Some(true) + } else { + Some(false) + }; + match block_type { + Some(true) => { + let early_return_stack = take(&mut self.early_return_stack); + let mut effects = take(&mut self.effects); + let hoisted_effects = take(&mut self.hoisted_effects); + n.visit_children_with_path(self, ast_path); + self.end_early_return_block(); + self.effects.append(&mut self.hoisted_effects); + effects.append(&mut self.effects); + self.hoisted_effects = hoisted_effects; + self.effects = effects; + self.early_return_stack = early_return_stack; } - (_, true) => { - self.add_conditional_effect( - &stmt.test, - ast_path, - AstParentKind::IfStmt(IfStmtField::Test), - stmt.span(), - ConditionalKind::IfElse { then, r#else }, - ); + Some(false) => { + n.visit_children_with_path(self, ast_path); + if self.end_early_return_block() { + self.early_return_stack.push(EarlyReturn::Always { + prev_effects: take(&mut self.effects), + start_ast_path: as_parent_path(ast_path), + }); + } } - (false, false) => { - // no effects, can be ignored + None => { + n.visit_children_with_path(self, ast_path); } } } } impl<'a> Analyzer<'a> { + fn add_conditional_if_effect_with_early_return( + &mut self, + test: &Expr, + ast_path: &AstNodePath>, + condition_ast_kind: AstParentKind, + span: Span, + then: Option, + r#else: Option, + early_return_when_true: bool, + early_return_when_false: bool, + ) { + if then.is_none() && r#else.is_none() && !early_return_when_false && !early_return_when_true + { + return; + } + let condition = self.eval_context.eval(test); + if condition.is_unknown() { + if let Some(mut then) = then { + self.effects.append(&mut then.effects); + } + if let Some(mut r#else) = r#else { + self.effects.append(&mut r#else.effects); + } + return; + } + match (early_return_when_true, early_return_when_false) { + (true, false) => { + self.early_return_stack.push(EarlyReturn::Conditional { + prev_effects: take(&mut self.effects), + start_ast_path: as_parent_path(ast_path), + condition, + then, + r#else, + condition_ast_path: as_parent_path_with(ast_path, condition_ast_kind), + span, + in_try: is_in_try(ast_path), + early_return_condition_value: true, + }); + } + (false, true) => { + self.early_return_stack.push(EarlyReturn::Conditional { + prev_effects: take(&mut self.effects), + start_ast_path: as_parent_path(ast_path), + condition, + then, + r#else, + condition_ast_path: as_parent_path_with(ast_path, condition_ast_kind), + span, + in_try: is_in_try(ast_path), + early_return_condition_value: false, + }); + } + (false, false) | (true, true) => { + let kind = match (then, r#else) { + (Some(then), Some(r#else)) => ConditionalKind::IfElse { then, r#else }, + (Some(then), None) => ConditionalKind::If { then }, + (None, Some(r#else)) => ConditionalKind::Else { r#else }, + (None, None) => unreachable!(), + }; + self.add_effect(Effect::Conditional { + condition, + kind: Box::new(kind), + ast_path: as_parent_path_with(ast_path, condition_ast_kind), + span, + in_try: is_in_try(ast_path), + }); + if early_return_when_false && early_return_when_true { + self.early_return_stack.push(EarlyReturn::Always { + prev_effects: take(&mut self.effects), + start_ast_path: as_parent_path(ast_path), + }); + } + } + } + } + fn add_conditional_effect( &mut self, test: &Expr, @@ -1762,11 +2065,22 @@ impl<'a> Analyzer<'a> { ConditionalKind::If { then } => { self.effects.append(&mut then.effects); } + ConditionalKind::Else { r#else } => { + self.effects.append(&mut r#else.effects); + } ConditionalKind::IfElse { then, r#else } | ConditionalKind::Ternary { then, r#else } => { self.effects.append(&mut then.effects); self.effects.append(&mut r#else.effects); } + ConditionalKind::IfElseMultiple { then, r#else } => { + for block in then { + self.effects.append(&mut block.effects); + } + for block in r#else { + self.effects.append(&mut block.effects); + } + } ConditionalKind::And { expr } | ConditionalKind::Or { expr } | ConditionalKind::NullishCoalescing { expr } => { diff --git a/crates/turbopack-ecmascript/src/analyzer/mod.rs b/crates/turbopack-ecmascript/src/analyzer/mod.rs index 11fa87a0175e8..2f51a9cf9e859 100644 --- a/crates/turbopack-ecmascript/src/analyzer/mod.rs +++ b/crates/turbopack-ecmascript/src/analyzer/mod.rs @@ -3866,6 +3866,11 @@ mod tests { queue .extend(then.effects.into_iter().rev().map(|e| (i, e))); } + ConditionalKind::Else { r#else } => { + queue.extend( + r#else.effects.into_iter().rev().map(|e| (i, e)), + ); + } ConditionalKind::IfElse { then, r#else } | ConditionalKind::Ternary { then, r#else } => { queue.extend( @@ -3874,6 +3879,18 @@ mod tests { queue .extend(then.effects.into_iter().rev().map(|e| (i, e))); } + ConditionalKind::IfElseMultiple { then, r#else } => { + for then in then { + queue.extend( + then.effects.into_iter().rev().map(|e| (i, e)), + ); + } + for r#else in r#else { + queue.extend( + r#else.effects.into_iter().rev().map(|e| (i, e)), + ); + } + } ConditionalKind::And { expr } | ConditionalKind::Or { expr } | ConditionalKind::NullishCoalescing { expr } => { @@ -3904,6 +3921,12 @@ mod tests { JsValue::member_call(Box::new(obj), Box::new(prop), new_args), )); } + Effect::Unreachable { .. } => { + resolved.push(( + format!("{parent} -> {i} unreachable"), + JsValue::unknown_empty(true, "unreachable"), + )); + } _ => {} } let time = start.elapsed(); diff --git a/crates/turbopack-ecmascript/src/path_visitor.rs b/crates/turbopack-ecmascript/src/path_visitor.rs index 5c83fbc9036cd..c207708b42a6f 100644 --- a/crates/turbopack-ecmascript/src/path_visitor.rs +++ b/crates/turbopack-ecmascript/src/path_visitor.rs @@ -153,6 +153,8 @@ impl VisitMutAstPath for ApplyVisitors<'_, '_> { method!(visit_mut_call_expr, CallExpr); method!(visit_mut_lit, Lit); method!(visit_mut_str, Str); + method!(visit_mut_block_stmt, BlockStmt); + method!(visit_mut_switch_case, SwitchCase); } #[cfg(test)] diff --git a/crates/turbopack-ecmascript/src/references/mod.rs b/crates/turbopack-ecmascript/src/references/mod.rs index f299844e72dab..680ee5e235f7a 100644 --- a/crates/turbopack-ecmascript/src/references/mod.rs +++ b/crates/turbopack-ecmascript/src/references/mod.rs @@ -134,6 +134,7 @@ use crate::{ type_issue::SpecifiedModuleTypeIssue, }, tree_shake::{find_turbopack_part_id_in_asserts, part_of_module, split}, + utils::AstPathRange, EcmascriptInputTransforms, EcmascriptModuleAsset, SpecifiedModuleType, TreeShakingMode, }; @@ -861,6 +862,11 @@ pub(crate) async fn analyse_ecmascript_module_internal( }; match effect { + Effect::Unreachable { start_ast_path } => { + analysis.add_code_gen(Unreachable::new( + AstPathRange::StartAfter(start_ast_path.to_vec()).cell(), + )); + } Effect::Conditional { condition, kind, @@ -872,7 +878,7 @@ pub(crate) async fn analyse_ecmascript_module_internal( macro_rules! inactive { ($block:ident) => { - analysis.add_code_gen(Unreachable::new(Vc::cell($block.ast_path.to_vec()))); + analysis.add_code_gen(Unreachable::new($block.range.clone().cell())); }; } macro_rules! condition { @@ -904,6 +910,19 @@ pub(crate) async fn analyse_ecmascript_module_internal( active!(then); } }, + ConditionalKind::Else { r#else } => match condition.is_truthy() { + Some(true) => { + condition!(ConstantConditionValue::Truthy); + inactive!(r#else); + } + Some(false) => { + condition!(ConstantConditionValue::Falsy); + active!(r#else); + } + None => { + active!(r#else); + } + }, ConditionalKind::IfElse { then, r#else } | ConditionalKind::Ternary { then, r#else } => match condition.is_truthy() { Some(true) => { @@ -921,6 +940,35 @@ pub(crate) async fn analyse_ecmascript_module_internal( active!(r#else); } }, + ConditionalKind::IfElseMultiple { then, r#else } => match condition.is_truthy() + { + Some(true) => { + condition!(ConstantConditionValue::Truthy); + for then in then { + active!(then); + } + for r#else in r#else { + inactive!(r#else); + } + } + Some(false) => { + condition!(ConstantConditionValue::Falsy); + for then in then { + inactive!(then); + } + for r#else in r#else { + active!(r#else); + } + } + None => { + for then in then { + active!(then); + } + for r#else in r#else { + active!(r#else); + } + } + }, ConditionalKind::And { expr } => match condition.is_truthy() { Some(true) => { condition!(ConstantConditionValue::Truthy); diff --git a/crates/turbopack-ecmascript/src/references/unreachable.rs b/crates/turbopack-ecmascript/src/references/unreachable.rs index 77365b0a3c527..dea536e865421 100644 --- a/crates/turbopack-ecmascript/src/references/unreachable.rs +++ b/crates/turbopack-ecmascript/src/references/unreachable.rs @@ -1,24 +1,40 @@ +use std::mem::take; + use anyhow::Result; -use swc_core::quote; +use swc_core::{ + common::{util::take::Take, Spanned}, + ecma::{ + ast::{ + ArrayPat, ArrowExpr, AssignPat, AssignPatProp, BindingIdent, BlockStmt, ClassDecl, + Decl, FnDecl, Ident, KeyValuePatProp, ObjectPat, ObjectPatProp, Pat, RestPat, Stmt, + VarDecl, VarDeclKind, VarDeclarator, + }, + visit::{ + fields::{BlockStmtField, SwitchCaseField}, + AstParentKind, VisitMut, VisitMutWith, + }, + }, + quote, +}; use turbo_tasks::Vc; use turbopack_core::chunk::ChunkingContext; -use super::AstPath; use crate::{ code_gen::{CodeGenerateable, CodeGeneration}, create_visitor, + utils::AstPathRange, }; #[turbo_tasks::value] pub struct Unreachable { - path: Vc, + range: Vc, } #[turbo_tasks::value_impl] impl Unreachable { #[turbo_tasks::function] - pub fn new(path: Vc) -> Vc { - Self::cell(Unreachable { path }) + pub fn new(range: Vc) -> Vc { + Self::cell(Unreachable { range }) } } @@ -29,20 +45,226 @@ impl CodeGenerateable for Unreachable { &self, _context: Vc>, ) -> Result> { - let path = self.path.await?; - let visitors = [ - // Unreachable might be used on Stmt or Expr - create_visitor!(exact path, visit_mut_expr(expr: &mut Expr) { - *expr = quote!("(\"TURBOPACK unreachable\", undefined)" as Expr); - }), - create_visitor!(exact path, visit_mut_stmt(stmt: &mut Stmt) { - // TODO(WEB-553) walk ast to find all `var` declarations and keep them - // since they hoist out of the scope - *stmt = quote!("{\"TURBOPACK unreachable\";}" as Stmt); - }), - ] - .into(); + let range = self.range.await?; + let visitors = match &*range { + AstPathRange::Exact(path) => { + [ + // Unreachable might be used on Stmt or Expr + create_visitor!(exact path, visit_mut_expr(expr: &mut Expr) { + *expr = quote!("(\"TURBOPACK unreachable\", undefined)" as Expr); + }), + create_visitor!(exact path, visit_mut_stmt(stmt: &mut Stmt) { + // TODO(WEB-553) walk ast to find all `var` declarations and keep them + // since they hoist out of the scope + let mut replacement = Vec::new(); + replacement.push(quote!("\"TURBOPACK unreachable\";" as Stmt)); + stmt.visit_mut_with(&mut ExtractDeclarations { + stmts: &mut replacement, + in_nested_block_scope: false, + }); + *stmt = Stmt::Block(BlockStmt { + span: stmt.span(), + stmts: replacement, + }); + }), + ] + .into() + } + AstPathRange::StartAfter(path) => { + let mut parent = &path[..]; + while !parent.is_empty() + && !matches!(parent.last().unwrap(), AstParentKind::Stmt(_)) + { + parent = &parent[0..parent.len() - 1]; + } + if !parent.is_empty() { + parent = &parent[0..parent.len() - 1]; + fn replace(stmts: &mut Vec, start_index: usize) { + if stmts.len() > start_index + 1 { + let unreachable = stmts + .splice( + start_index + 1.., + [quote!("\"TURBOPACK unreachable\";" as Stmt)].into_iter(), + ) + .collect::>(); + for mut stmt in unreachable { + stmt.visit_mut_with(&mut ExtractDeclarations { + stmts, + in_nested_block_scope: false, + }); + } + } + } + let (parent, [last]) = parent.split_at(parent.len() - 1) else { + unreachable!(); + }; + if let &AstParentKind::BlockStmt(BlockStmtField::Stmts(start_index)) = last { + [ + create_visitor!(exact parent, visit_mut_block_stmt(block: &mut BlockStmt) { + replace(&mut block.stmts, start_index); + }), + ] + .into() + } else if let &AstParentKind::SwitchCase(SwitchCaseField::Cons(start_index)) = + last + { + [ + create_visitor!(exact parent, visit_mut_switch_case(case: &mut SwitchCase) { + replace(&mut case.cons, start_index); + }), + ] + .into() + } else { + Vec::new() + } + } else { + Vec::new() + } + } + }; Ok(CodeGeneration { visitors }.cell()) } } + +struct ExtractDeclarations<'a> { + stmts: &'a mut Vec, + in_nested_block_scope: bool, +} + +impl<'a> VisitMut for ExtractDeclarations<'a> { + fn visit_mut_var_decl(&mut self, decl: &mut VarDecl) { + let VarDecl { + span, + kind, + declare, + decls, + } = decl; + if self.in_nested_block_scope && !matches!(kind, VarDeclKind::Var) { + return; + } + let mut idents = Vec::new(); + for decl in take(decls) { + collect_idents(&decl.name, &mut idents); + } + let decls = idents + .into_iter() + .map(|ident| VarDeclarator { + span: ident.span, + name: Pat::Ident(BindingIdent { + id: ident, + type_ann: None, + }), + init: if matches!(kind, VarDeclKind::Const) { + Some(quote!("undefined" as Box)) + } else { + None + }, + definite: false, + }) + .collect(); + self.stmts.push(Stmt::Decl(Decl::Var(Box::new(VarDecl { + span: *span, + kind: *kind, + declare: *declare, + decls, + })))); + } + + fn visit_mut_fn_decl(&mut self, decl: &mut FnDecl) { + let FnDecl { + declare, + ident, + function, + } = decl; + self.stmts.push(Stmt::Decl(Decl::Fn(FnDecl { + declare: *declare, + ident: ident.take(), + function: function.take(), + }))); + } + + fn visit_mut_constructor(&mut self, _: &mut swc_core::ecma::ast::Constructor) { + // Do not walk into constructors + } + + fn visit_mut_function(&mut self, _: &mut swc_core::ecma::ast::Function) { + // Do not walk into functions + } + + fn visit_mut_getter_prop(&mut self, _: &mut swc_core::ecma::ast::GetterProp) { + // Do not walk into getter properties + } + + fn visit_mut_setter_prop(&mut self, _: &mut swc_core::ecma::ast::SetterProp) { + // Do not walk into setter properties + } + + fn visit_mut_arrow_expr(&mut self, _: &mut ArrowExpr) { + // Do not walk into arrow expressions + } + + fn visit_mut_class_decl(&mut self, decl: &mut ClassDecl) { + let ClassDecl { declare, ident, .. } = decl; + self.stmts.push(Stmt::Decl(Decl::Var(Box::new(VarDecl { + span: ident.span, + declare: *declare, + decls: vec![VarDeclarator { + span: ident.span, + name: Pat::Ident(BindingIdent { + type_ann: None, + id: ident.clone(), + }), + init: None, + definite: false, + }], + kind: VarDeclKind::Let, + })))); + } + + fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt) { + let old = self.in_nested_block_scope; + self.in_nested_block_scope = true; + n.visit_mut_children_with(self); + self.in_nested_block_scope = old; + } +} + +fn collect_idents(pat: &Pat, idents: &mut Vec) { + match pat { + Pat::Ident(ident) => { + idents.push(ident.id.clone()); + } + Pat::Array(ArrayPat { elems, .. }) => { + for elem in elems.iter() { + if let Some(elem) = elem.as_ref() { + collect_idents(elem, idents); + } + } + } + Pat::Rest(RestPat { arg, .. }) => { + collect_idents(arg, idents); + } + Pat::Object(ObjectPat { props, .. }) => { + for prop in props.iter() { + match prop { + ObjectPatProp::KeyValue(KeyValuePatProp { value, .. }) => { + collect_idents(value, idents); + } + ObjectPatProp::Assign(AssignPatProp { key, .. }) => { + idents.push(key.id.clone()); + } + ObjectPatProp::Rest(RestPat { arg, .. }) => { + collect_idents(arg, idents); + } + } + } + } + Pat::Assign(AssignPat { left, .. }) => { + collect_idents(left, idents); + } + Pat::Invalid(_) | Pat::Expr(_) => { + // ignore + } + } +} diff --git a/crates/turbopack-ecmascript/src/utils.rs b/crates/turbopack-ecmascript/src/utils.rs index 9e547a4fafcfa..864c5a1130002 100644 --- a/crates/turbopack-ecmascript/src/utils.rs +++ b/crates/turbopack-ecmascript/src/utils.rs @@ -1,7 +1,10 @@ use serde::Serialize; use swc_core::{ common::DUMMY_SP, - ecma::ast::{Expr, Lit, Str}, + ecma::{ + ast::{Expr, Lit, Str}, + visit::AstParentKind, + }, }; use turbopack_core::{chunk::ModuleId, resolve::pattern::Pattern}; @@ -126,3 +129,13 @@ format_iter!(std::fmt::Octal); format_iter!(std::fmt::Pointer); format_iter!(std::fmt::UpperExp); format_iter!(std::fmt::UpperHex); + +#[turbo_tasks::value(shared, serialization = "none")] +#[derive(Debug, Clone)] +pub enum AstPathRange { + /// The ast path to the block or expression. + Exact(#[turbo_tasks(trace_ignore)] Vec), + /// The ast path to a expression just before the range in the parent of the + /// specific ast path. + StartAfter(#[turbo_tasks(trace_ignore)] Vec), +} diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/graph-effects.snapshot index e68b8967c1f18..12c37300f90ac 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/graph-effects.snapshot @@ -103,51 +103,108 @@ ), ), EffectsBlock { - effects: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 1, + effects: [ + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Script( + Body( + 1, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + Stmt( + Decl, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - ], + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + ], + ), }, ), ], @@ -285,51 +342,108 @@ ), ), EffectsBlock { - effects: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 2, + effects: [ + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Script( + Body( + 2, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + Stmt( + Decl, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - ], + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + ], + ), }, ), ], @@ -711,51 +825,107 @@ span: 281..302#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 3, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Script( + Body( + 3, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + Stmt( + Decl, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - ], + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + ], + ), }, ), ], @@ -966,4 +1136,36 @@ span: 339..360#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/resolved-effects.snapshot index de46b90acf8ae..8e7f145f81a6a 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/array-map/resolved-effects.snapshot @@ -1,19 +1,35 @@ 0 -> 2 member call = ["../lib/a.js", "../lib/b.js"]["map"]((...) => file) -0 -> 4 member call = ["../lib/a.js", "../lib/b.js"]["map"]((...) => [file]) +2 -> 3 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 6 member call = ["../lib/a.js", "../lib/b.js"]["map"]((...) => FreeVar(require)["resolve"](file)) +0 -> 5 member call = ["../lib/a.js", "../lib/b.js"]["map"]((...) => [file]) -6 -> 8 free var = FreeVar(require) +5 -> 6 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -6 -> 9 member call = require*0*["resolve"](???*1*) +0 -> 8 member call = ["../lib/a.js", "../lib/b.js"]["map"]((...) => FreeVar(require)["resolve"](file)) + +8 -> 10 free var = FreeVar(require) + +8 -> 11 member call = require*0*["resolve"](???*1*) - *0* require: The require method from CommonJS - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 11 free var = FreeVar(require) +8 -> 12 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 12 member call = require*0*["resolve"](???*1*) +0 -> 14 free var = FreeVar(require) + +0 -> 15 member call = require*0*["resolve"](???*1*) - *0* require: The require method from CommonJS - *1* arguments[0] ⚠️ function calls are not analysed yet + +0 -> 16 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/graph-effects.snapshot index fe51488c7066f..2f7ac406fa11c 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/graph-effects.snapshot @@ -1 +1,414 @@ -[] +[ + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, +] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/resolved-effects.snapshot new file mode 100644 index 0000000000000..ac20527f36784 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/arrow/resolved-effects.snapshot @@ -0,0 +1,31 @@ +0 -> 1 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 7 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 8 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/class_super/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/class_super/graph-effects.snapshot index 99bc32cbd669b..18837813012ef 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/class_super/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/class_super/graph-effects.snapshot @@ -218,70 +218,72 @@ in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 2, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Class, - ), - ClassDecl( - Class, - ), - Class( - Body( - 0, + Module( + Body( + 2, + ), ), - ), - ClassMember( - Constructor, - ), - Constructor( - Body, - ), - BlockStmt( - Stmts( - 0, + ModuleItem( + Stmt, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + Stmt( + Decl, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - ], + Decl( + Class, + ), + ClassDecl( + Class, + ), + Class( + Body( + 0, + ), + ), + ClassMember( + Constructor, + ), + Constructor( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + ], + ), }, ), ], diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-effects.snapshot index b3724a9a77977..985f12d750285 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-effects.snapshot @@ -6,97 +6,101 @@ kind: Ternary { then: EffectsBlock { effects: [], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 0, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Module( + Body( + 0, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + ModuleItem( + Stmt, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 0, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Module( + Body( + 0, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + ModuleItem( + Stmt, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -454,97 +458,101 @@ kind: Ternary { then: EffectsBlock { effects: [], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 1, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Module( + Body( + 1, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + ModuleItem( + Stmt, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 1, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Module( + Body( + 1, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + ModuleItem( + Stmt, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -754,25 +762,27 @@ in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 3, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -837,25 +847,27 @@ in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 3, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - ], + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -898,7 +910,7 @@ ), Module( Body( - 6, + 7, ), ), ModuleItem( @@ -928,29 +940,31 @@ Ident, ), ], - span: 331..332#2, + span: 354..355#2, in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 6, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -965,7 +979,7 @@ ), Module( Body( - 6, + 7, ), ), ModuleItem( @@ -995,29 +1009,188 @@ Ident, ), ], - span: 345..346#2, + span: 368..369#2, in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 6, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 340..372#0, + in_try: false, + }, + Conditional { + condition: Constant( + True, + ), + kind: IfElse { + then: EffectsBlock { + effects: [ + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + else: EffectsBlock { + effects: [], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), }, }, ast_path: [ @@ -1026,12 +1199,29 @@ ), Module( Body( - 6, + 8, ), ), ModuleItem( Stmt, ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), Stmt( If, ), @@ -1039,7 +1229,111 @@ Test, ), ], - span: 317..349#0, + span: 399..434#0, + in_try: false, + }, + Call { + func: FreeVar( + "import", + ), + args: [ + Value( + Constant( + Str( + Word( + "c", + ), + ), + ), + ), + ], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 438..449#0, + in_try: false, + }, + ImportedBinding { + esm_reference_index: 4, + export: Some( + "z", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Ident, + ), + ], + span: 453..454#2, in_try: false, }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-explained.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-explained.snapshot index f235469d75217..5bac4c7735e6a 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-explained.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph-explained.snapshot @@ -7,3 +7,7 @@ b = (???*0* | FreeVar(import)("a") | FreeVar(import)("b")) c = FreeVar(import)( ((FreeVar(process)["env"]["NEXT_RUNTIME"] === "edge") ? "next/dist/compiled/@vercel/og/index.edge.js" : "next/dist/compiled/@vercel/og/index.node.js") ) + +earlyExit = (...) => (undefined | hoisted) + +hoisted = (...) => undefined diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph.snapshot index 0199caec2444a..062112053d2ea 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/graph.snapshot @@ -130,4 +130,36 @@ ], ), ), + ( + "earlyExit", + Function( + 4, + 374, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + Variable( + ( + "hoisted", + #7, + ), + ), + ], + logical_property: None, + }, + ), + ), + ( + "hoisted", + Function( + 2, + 459, + Constant( + Undefined, + ), + ), + ), ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/input.js b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/input.js index a647f189f4f13..18d18fd2386bd 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/input.js +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/input.js @@ -14,9 +14,21 @@ if (true) { import { x } from "x"; import { y } from "y"; +import { z } from "y"; if (true) { x; } else { y; } + +function earlyExit() { + if (true) { + return hoisted; + } + + import("c"); + z; + + function hoisted() {} +} diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-effects.snapshot index fde76dc6ed13e..75dcd47daabca 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-effects.snapshot @@ -25,3 +25,12 @@ - *0* import: The dynamic import() method from the ESM specification: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#dynamic_imports 0 -> 11 conditional = true + +0 -> 14 conditional = true + +14 -> 15 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 16 call = import*0*("c") +- *0* import: The dynamic import() method from the ESM specification: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#dynamic_imports diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-explained.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-explained.snapshot index 666a893d17dce..b397510a2c430 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-explained.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/conditional-import/resolved-explained.snapshot @@ -14,3 +14,7 @@ c = ???*0* - *2* (process.env*3*["NEXT_RUNTIME"] === "edge") ⚠️ nested operation - *3* process.env: The Node.js process.env property: https://nodejs.org/api/process.html#processenv + +earlyExit = (...) => (undefined | hoisted) + +hoisted = (...) => undefined diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot index ddde9ecd2e030..9d75bc0200bb4 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/graph-effects.snapshot @@ -10,7 +10,7 @@ ), Module( Body( - 1, + 2, ), ), ModuleItem( @@ -20,19 +20,24 @@ Decl, ), Decl( - Fn, + Var, ), - FnDecl( - Function, + VarDecl( + Decls( + 0, + ), ), - Function( + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( Params( 0, ), ), - Param( - Pat, - ), Pat( Object, ), @@ -51,15 +56,11 @@ Ident, ), ], - span: 62..67#2, + span: 117..122#2, in_try: false, }, - ImportedBinding { - esm_reference_index: 1, - export: Some( - "named", - ), - ast_path: [ + Unreachable { + start_ast_path: [ Program( Module, ), @@ -89,10 +90,55 @@ Arrow, ), ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ImportedBinding { + esm_reference_index: 1, + export: Some( + "named", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( Params( 0, ), ), + Param( + Pat, + ), Pat( Object, ), @@ -111,7 +157,42 @@ Ident, ), ], - span: 117..122#2, + span: 62..67#2, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot new file mode 100644 index 0000000000000..a5ca2867a4884 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/default-args/resolved-effects.snapshot @@ -0,0 +1,7 @@ +0 -> 2 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-effects.snapshot new file mode 100644 index 0000000000000..933b51195f1ea --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-effects.snapshot @@ -0,0 +1,4086 @@ +[ + Conditional { + condition: Constant( + True, + ), + kind: IfElse { + then: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "a1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 34..36#1, + in_try: false, + }, + Call { + func: FreeVar( + "a1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 34..38#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + else: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "a2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 58..60#1, + in_try: false, + }, + Call { + func: FreeVar( + "a2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 58..62#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 0, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 18..55#0, + in_try: false, + }, + Conditional { + condition: Constant( + True, + ), + kind: IfElseMultiple { + then: [ + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "b1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 100..102#1, + in_try: false, + }, + Call { + func: FreeVar( + "b1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 100..104#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + ], + else: [ + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "b2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 133..135#1, + in_try: false, + }, + Call { + func: FreeVar( + "b2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 133..137#0, + in_try: false, + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "b3", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 145..147#1, + in_try: false, + }, + Call { + func: FreeVar( + "b3", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 145..149#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + ], + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 84..142#0, + in_try: false, + }, + Conditional { + condition: Constant( + True, + ), + kind: IfElse { + then: EffectsBlock { + effects: [ + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + else: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "c1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 201..203#1, + in_try: false, + }, + Call { + func: FreeVar( + "c1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 201..205#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 171..198#0, + in_try: false, + }, + Conditional { + condition: Constant( + True, + ), + kind: IfElseMultiple { + then: [ + EffectsBlock { + effects: [ + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + ], + else: [ + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "d1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 266..268#1, + in_try: false, + }, + Call { + func: FreeVar( + "d1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 266..270#0, + in_try: false, + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "d2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 278..280#1, + in_try: false, + }, + Call { + func: FreeVar( + "d2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 278..282#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + ], + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 3, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 227..275#0, + in_try: false, + }, + Conditional { + condition: Constant( + False, + ), + kind: IfElseMultiple { + then: [ + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "e1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 321..323#1, + in_try: false, + }, + Call { + func: FreeVar( + "e1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 321..325#0, + in_try: false, + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "e2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 356..358#1, + in_try: false, + }, + Call { + func: FreeVar( + "e2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 356..360#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + ], + else: [ + EffectsBlock { + effects: [ + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + ], + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 4, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 304..353#0, + in_try: false, + }, + Conditional { + condition: Constant( + False, + ), + kind: IfElse { + then: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "f1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 5, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 424..426#1, + in_try: false, + }, + Call { + func: FreeVar( + "f1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 5, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 424..428#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 5, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + else: EffectsBlock { + effects: [ + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 5, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 5, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 5, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 382..421#0, + in_try: false, + }, + Conditional { + condition: Constant( + False, + ), + kind: IfElseMultiple { + then: [ + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "g1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 467..469#1, + in_try: false, + }, + Call { + func: FreeVar( + "g1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 467..471#0, + in_try: false, + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "g3", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 512..514#1, + in_try: false, + }, + Call { + func: FreeVar( + "g3", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 512..516#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + ], + else: [ + EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "g2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 488..490#1, + in_try: false, + }, + Call { + func: FreeVar( + "g2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 488..492#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + ], + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 6, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 450..509#0, + in_try: false, + }, + Conditional { + condition: Constant( + False, + ), + kind: IfElse { + then: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "h2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 590..592#1, + in_try: false, + }, + Call { + func: FreeVar( + "h2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 590..594#0, + in_try: false, + }, + ], + range: StartAfter( + [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + ), + }, + else: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "h1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 566..568#1, + in_try: false, + }, + Call { + func: FreeVar( + "h1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 566..570#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Module, + ), + Module( + Body( + 7, + ), + ), + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 538..587#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "i1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 642..644#1, + in_try: false, + }, + Call { + func: FreeVar( + "i1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + ], + span: 642..646#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Return, + ), + ], + }, + FreeVar { + var: FreeVar( + "i2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 657..659#1, + in_try: false, + }, + Call { + func: FreeVar( + "i2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + ], + span: 657..661#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 8, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + FreeVar { + var: FreeVar( + "i1", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 9, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 715..717#1, + in_try: false, + }, + Call { + func: FreeVar( + "i1", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 9, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + ], + span: 715..719#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 9, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + FreeVar { + var: FreeVar( + "i2", + ), + ast_path: [ + Program( + Module, + ), + Module( + Body( + 9, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 734..736#1, + in_try: false, + }, + Call { + func: FreeVar( + "i2", + ), + args: [], + ast_path: [ + Program( + Module, + ), + Module( + Body( + 9, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + ], + span: 734..738#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 9, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, +] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-explained.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-explained.snapshot new file mode 100644 index 0000000000000..26ea050f58385 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph-explained.snapshot @@ -0,0 +1,23 @@ +a = (...) => (undefined | FreeVar(undefined)) + +b = (...) => (undefined | FreeVar(undefined)) + +c = (...) => (undefined | FreeVar(undefined)) + +d = (...) => (undefined | FreeVar(undefined)) + +e = (...) => (undefined | FreeVar(undefined)) + +f = (...) => (undefined | FreeVar(undefined)) + +g = (...) => (undefined | FreeVar(undefined)) + +h = (...) => (undefined | FreeVar(undefined)) + +i = (...) => (FreeVar(i1)() | FreeVar(i2)()) + +j#2 = (...) => (FreeVar(i1)() | FreeVar(i2)()) + +j#25 = arguments[0] + +j#26 = arguments[0] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph.snapshot new file mode 100644 index 0000000000000..19a491dbc4fce --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/graph.snapshot @@ -0,0 +1,222 @@ +[ + ( + "a", + Function( + 4, + 1, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "b", + Function( + 4, + 67, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "c", + Function( + 4, + 154, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "d", + Function( + 4, + 210, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "e", + Function( + 4, + 287, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "f", + Function( + 4, + 365, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "g", + Function( + 4, + 433, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "h", + Function( + 4, + 521, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "i", + Function( + 6, + 606, + Alternatives { + total_nodes: 5, + values: [ + Call( + 2, + FreeVar( + "i1", + ), + [], + ), + Call( + 2, + FreeVar( + "i2", + ), + [], + ), + ], + logical_property: None, + }, + ), + ), + ( + "j#2", + Function( + 6, + 673, + Alternatives { + total_nodes: 5, + values: [ + Call( + 2, + FreeVar( + "i1", + ), + [], + ), + Call( + 2, + FreeVar( + "i2", + ), + [], + ), + ], + logical_property: None, + }, + ), + ), + ( + "j#25", + Argument( + 606, + 0, + ), + ), + ( + "j#26", + Argument( + 673, + 0, + ), + ), +] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/input.js b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/input.js new file mode 100644 index 0000000000000..d9571b3076d26 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/input.js @@ -0,0 +1,81 @@ +function a() { + if (true) { + a1(); + return; + } + a2(); +} + +function b() { + if (true) { + b1(); + return; + } else { + b2(); + } + b3(); +} + +function c() { + if (true) { + return; + } + c1(); +} + +function d() { + if (true) { + return; + } else { + d1(); + } + d2(); +} + +function e() { + if (false) { + e1(); + } else { + return; + } + e2(); +} + +function f() { + if (false) { + } else { + return; + } + f1(); +} + +function g() { + if (false) { + g1(); + } else { + g2(); + return; + } + g3(); +} + +function h() { + if (false) { + } else { + h1(); + return; + } + h2(); +} + +export function i(j) { + if (j < 1) return i1(); + return i2(); +} + +export function j(j) { + if (j < 1) { + return i1(); + } + return i2(); +} diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-effects.snapshot new file mode 100644 index 0000000000000..c6962b905e502 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-effects.snapshot @@ -0,0 +1,203 @@ +0 -> 1 conditional = true + +1 -> 2 free var = FreeVar(a1) + +1 -> 3 call = ???*0*() +- *0* FreeVar(a1) + ⚠️ unknown global + ⚠️ This value might have side effects + +1 -> 4 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1 -> 5 free var = FreeVar(a2) + +1 -> 6 call = ???*0*() +- *0* FreeVar(a2) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 7 conditional = true + +7 -> 8 free var = FreeVar(b3) + +7 -> 9 call = ???*0*() +- *0* FreeVar(b3) + ⚠️ unknown global + ⚠️ This value might have side effects + +7 -> 10 free var = FreeVar(b2) + +7 -> 11 call = ???*0*() +- *0* FreeVar(b2) + ⚠️ unknown global + ⚠️ This value might have side effects + +7 -> 12 free var = FreeVar(b1) + +7 -> 13 call = ???*0*() +- *0* FreeVar(b1) + ⚠️ unknown global + ⚠️ This value might have side effects + +7 -> 14 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 15 conditional = true + +15 -> 16 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +15 -> 17 free var = FreeVar(c1) + +15 -> 18 call = ???*0*() +- *0* FreeVar(c1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 19 conditional = true + +19 -> 20 free var = FreeVar(d2) + +19 -> 21 call = ???*0*() +- *0* FreeVar(d2) + ⚠️ unknown global + ⚠️ This value might have side effects + +19 -> 22 free var = FreeVar(d1) + +19 -> 23 call = ???*0*() +- *0* FreeVar(d1) + ⚠️ unknown global + ⚠️ This value might have side effects + +19 -> 24 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 25 conditional = false + +25 -> 26 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +25 -> 27 free var = FreeVar(e2) + +25 -> 28 call = ???*0*() +- *0* FreeVar(e2) + ⚠️ unknown global + ⚠️ This value might have side effects + +25 -> 29 free var = FreeVar(e1) + +25 -> 30 call = ???*0*() +- *0* FreeVar(e1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 31 conditional = false + +31 -> 32 free var = FreeVar(f1) + +31 -> 33 call = ???*0*() +- *0* FreeVar(f1) + ⚠️ unknown global + ⚠️ This value might have side effects + +31 -> 34 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 35 conditional = false + +35 -> 36 free var = FreeVar(g2) + +35 -> 37 call = ???*0*() +- *0* FreeVar(g2) + ⚠️ unknown global + ⚠️ This value might have side effects + +35 -> 38 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +35 -> 39 free var = FreeVar(g3) + +35 -> 40 call = ???*0*() +- *0* FreeVar(g3) + ⚠️ unknown global + ⚠️ This value might have side effects + +35 -> 41 free var = FreeVar(g1) + +35 -> 42 call = ???*0*() +- *0* FreeVar(g1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 43 conditional = false + +43 -> 44 free var = FreeVar(h2) + +43 -> 45 call = ???*0*() +- *0* FreeVar(h2) + ⚠️ unknown global + ⚠️ This value might have side effects + +43 -> 46 free var = FreeVar(h1) + +43 -> 47 call = ???*0*() +- *0* FreeVar(h1) + ⚠️ unknown global + ⚠️ This value might have side effects + +43 -> 48 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 49 free var = FreeVar(i1) + +0 -> 50 call = ???*0*() +- *0* FreeVar(i1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 51 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 52 free var = FreeVar(i2) + +0 -> 53 call = ???*0*() +- *0* FreeVar(i2) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 54 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 55 free var = FreeVar(i1) + +0 -> 56 call = ???*0*() +- *0* FreeVar(i1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 57 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 58 free var = FreeVar(i2) + +0 -> 59 call = ???*0*() +- *0* FreeVar(i2) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 60 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-explained.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-explained.snapshot new file mode 100644 index 0000000000000..5b708d3e78060 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/early-return/resolved-explained.snapshot @@ -0,0 +1,27 @@ +a = (...) => (undefined | FreeVar(undefined)) + +b = (...) => (undefined | FreeVar(undefined)) + +c = (...) => (undefined | FreeVar(undefined)) + +d = (...) => (undefined | FreeVar(undefined)) + +e = (...) => (undefined | FreeVar(undefined)) + +f = (...) => (undefined | FreeVar(undefined)) + +g = (...) => (undefined | FreeVar(undefined)) + +h = (...) => (undefined | FreeVar(undefined)) + +i = (...) => (FreeVar(i1)() | FreeVar(i2)()) + +j#2 = (...) => (FreeVar(i1)() | FreeVar(i2)()) + +j#25 = ???*0* +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +j#26 = ???*0* +- *0* arguments[0] + ⚠️ function calls are not analysed yet diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot index 9d43d7211e5e9..fc8019e66362e 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/graph-effects.snapshot @@ -1,4 +1,42 @@ [ + Call { + func: Variable( + ( + "generateBinPath", + #2, + ), + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 598..615#0, + in_try: false, + }, FreeVar { var: FreeVar( "require", @@ -291,6 +329,38 @@ span: 317..328#1, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 4, + ), + ), + Stmt( + Return, + ), + ], + }, Call { func: Variable( ( @@ -592,42 +662,36 @@ span: 515..551#0, in_try: true, }, - Call { - func: Variable( - ( - "generateBinPath", - #2, - ), - ), - args: [], - ast_path: [ + Unreachable { + start_ast_path: [ Program( Script, ), Script( Body( - 5, + 4, ), ), Stmt( Decl, ), Decl( - Var, + Fn, ), - VarDecl( - Decls( - 0, - ), + FnDecl( + Function, ), - VarDeclarator( - Init, + Function( + Body, ), - Expr( - Call, + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Return, ), ], - span: 598..615#0, - in_try: false, }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot index a352ac825a591..23c70802466e3 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild-reduced/resolved-effects.snapshot @@ -1,20 +1,26 @@ -0 -> 1 free var = FreeVar(require) +0 -> 1 call = (...) => binPath() -0 -> 2 call = require*0*("path") +0 -> 2 free var = FreeVar(require) + +0 -> 3 call = require*0*("path") - *0* require: The require method from CommonJS -0 -> 3 free var = FreeVar(require) +0 -> 4 free var = FreeVar(require) -0 -> 4 call = require*0*("path") +0 -> 5 call = require*0*("path") - *0* require: The require method from CommonJS -0 -> 6 free var = FreeVar(platformKey) +0 -> 7 free var = FreeVar(platformKey) + +0 -> 8 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 7 call = (...) => {"pkg": pkg, "subpath": subpath}() +0 -> 9 call = (...) => {"pkg": pkg, "subpath": subpath}() -0 -> 9 free var = FreeVar(require) +0 -> 11 free var = FreeVar(require) -0 -> 10 member call = require*0*["resolve"]( +0 -> 12 member call = require*0*["resolve"]( `${(???*1* | "esbuild-windows-arm64" | "esbuild-windows-32" | "esbuild-windows-64" | ???*2* | ???*4*)}/${(???*5* | "esbuild.exe" | ???*6*)}` ) - *0* require: The require method from CommonJS @@ -33,4 +39,6 @@ - *6* unknown mutation ⚠️ This value might have side effects -0 -> 11 call = (...) => binPath() +0 -> 13 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot index 3c97beeacce15..e870061a48909 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/graph-effects.snapshot @@ -1,7 +1,7 @@ [ FreeVar { var: FreeVar( - "require", + "ESBUILD_BINARY_PATH", ), ast_path: [ Program( @@ -9,7 +9,7 @@ ), Script( Body( - 0, + 7, ), ), Stmt( @@ -27,43 +27,77 @@ Init, ), Expr( - Call, + Arrow, ), - CallExpr( - Callee, + ArrowExpr( + Body, ), - Callee( + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Bin, + ), + BinExpr( + Left, + ), + Expr( + Paren, + ), + ParenExpr( Expr, ), + Expr( + Bin, + ), + BinExpr( + Left, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), Expr( Ident, ), ], - span: 12..19#1, + span: 2687..2706#1, in_try: false, }, - Call { - func: FreeVar( - "require", + Member { + obj: Variable( + ( + "path2", + #2, + ), ), - args: [ - Value( - Constant( - Str( - Word( - "path", - ), - ), + prop: Constant( + Str( + Atom( + "basename", ), ), - ], + ), ast_path: [ Program( Script, ), Script( Body( - 0, + 7, ), ), Stmt( @@ -81,38 +115,48 @@ Init, ), Expr( - Call, + Arrow, ), - ], - span: 12..27#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, + ArrowExpr( + Body, ), - Script( - Body( - 1, + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, ), ), Stmt( - Decl, + If, ), - Decl( - Var, + IfStmt( + Test, ), - VarDecl( - Decls( - 0, - ), + Expr( + Bin, ), - VarDeclarator( - Init, + BinExpr( + Right, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Bin, + ), + BinExpr( + Left, + ), + Expr( + Bin, + ), + BinExpr( + Left, ), Expr( Call, @@ -124,34 +168,23 @@ Expr, ), Expr( - Ident, + Member, ), ], - span: 41..48#1, + span: 2725..2739#0, in_try: false, }, - Call { - func: FreeVar( - "require", + FreeVar { + var: FreeVar( + "__filename", ), - args: [ - Value( - Constant( - Str( - Word( - "path", - ), - ), - ), - ), - ], ast_path: [ Program( Script, ), Script( Body( - 1, + 7, ), ), Stmt( @@ -169,67 +202,85 @@ Init, ), Expr( - Call, + Arrow, ), - ], - span: 41..56#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, + ArrowExpr( + Body, ), - Script( - Body( - 2, + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, ), ), Stmt( - Decl, + If, ), - Decl( - Var, + IfStmt( + Test, ), - VarDecl( - Decls( - 0, - ), + Expr( + Bin, ), - VarDeclarator( - Init, + BinExpr( + Right, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Bin, + ), + BinExpr( + Left, + ), + Expr( + Bin, + ), + BinExpr( + Left, ), Expr( Call, ), CallExpr( - Callee, + Args( + 0, + ), ), - Callee( + ExprOrSpread( Expr, ), Expr( Ident, ), ], - span: 67..74#1, + span: 2740..2750#1, in_try: false, }, - Call { - func: FreeVar( - "require", + MemberCall { + obj: Variable( + ( + "path2", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "basename", + ), + ), ), args: [ Value( - Constant( - Str( - Word( - "os", - ), - ), + FreeVar( + "__filename", ), ), ], @@ -239,7 +290,7 @@ ), Script( Body( - 2, + 7, ), ), Stmt( @@ -257,81 +308,69 @@ Init, ), Expr( - Call, + Arrow, ), - ], - span: 67..80#0, - in_try: false, - }, - Member { - obj: FreeVar( - "process", - ), - prop: Constant( - Str( - Atom( - "platform", - ), + ArrowExpr( + Body, ), - ), - ast_path: [ - Program( - Script, + BlockStmtOrExpr( + BlockStmt, ), - Script( - Body( - 5, + BlockStmt( + Stmts( + 0, ), ), Stmt( - Decl, - ), - Decl( - Fn, + If, ), - FnDecl( - Function, + IfStmt( + Test, ), - Function( - Body, + Expr( + Bin, ), - BlockStmt( - Stmts( - 2, - ), + BinExpr( + Right, ), - Stmt( - Decl, + Expr( + Paren, ), - Decl( - Var, + ParenExpr( + Expr, ), - VarDecl( - Decls( - 0, - ), + Expr( + Bin, ), - VarDeclarator( - Init, + BinExpr( + Left, ), Expr( - Tpl, + Bin, ), - Tpl( - Exprs( - 0, - ), + BinExpr( + Left, ), Expr( - Member, + Call, ), ], - span: 1005..1021#0, + span: 2725..2751#0, in_try: false, }, - FreeVar { - var: FreeVar( - "process", + Member { + obj: Variable( + ( + "path2", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "basename", + ), + ), ), ast_path: [ Program( @@ -339,74 +378,86 @@ ), Script( Body( - 5, + 7, ), ), Stmt( Decl, ), Decl( - Fn, + Var, ), - FnDecl( - Function, + VarDecl( + Decls( + 0, + ), ), - Function( + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( Body, ), + BlockStmtOrExpr( + BlockStmt, + ), BlockStmt( Stmts( - 2, + 0, ), ), Stmt( - Decl, + If, ), - Decl( - Var, + IfStmt( + Test, ), - VarDecl( - Decls( - 0, - ), + Expr( + Bin, ), - VarDeclarator( - Init, + BinExpr( + Right, ), Expr( - Tpl, + Paren, ), - Tpl( - Exprs( - 0, - ), + ParenExpr( + Expr, ), Expr( - Member, + Bin, ), - MemberExpr( - Obj, + BinExpr( + Right, ), Expr( - Ident, + Bin, + ), + BinExpr( + Left, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, ), ], - span: 1005..1012#1, + span: 2775..2789#0, in_try: false, }, - Member { - obj: Variable( - ( - "os", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "arch", - ), - ), + FreeVar { + var: FreeVar( + "__dirname", ), ast_path: [ Program( @@ -414,103 +465,113 @@ ), Script( Body( - 5, + 7, ), ), Stmt( Decl, ), Decl( - Fn, + Var, ), - FnDecl( - Function, + VarDecl( + Decls( + 0, + ), ), - Function( + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( Body, ), + BlockStmtOrExpr( + BlockStmt, + ), BlockStmt( Stmts( - 2, + 0, ), ), Stmt( - Decl, + If, ), - Decl( - Var, + IfStmt( + Test, ), - VarDecl( - Decls( - 0, - ), + Expr( + Bin, ), - VarDeclarator( - Init, + BinExpr( + Right, ), Expr( - Tpl, + Paren, ), - Tpl( - Exprs( - 1, - ), + ParenExpr( + Expr, + ), + Expr( + Bin, + ), + BinExpr( + Right, + ), + Expr( + Bin, + ), + BinExpr( + Left, ), Expr( Call, ), CallExpr( - Callee, + Args( + 0, + ), ), - Callee( + ExprOrSpread( Expr, ), Expr( - Member, + Ident, ), ], - span: 1025..1032#0, + span: 2790..2799#1, in_try: false, }, MemberCall { obj: Variable( ( - "os", + "path2", #2, ), ), prop: Constant( Str( Atom( - "arch", + "basename", ), ), ), - args: [], + args: [ + Value( + FreeVar( + "__dirname", + ), + ), + ], ast_path: [ Program( Script, ), Script( Body( - 5, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 2, + 7, ), ), Stmt( @@ -528,470 +589,195 @@ Init, ), Expr( - Tpl, - ), - Tpl( - Exprs( - 1, - ), - ), - Expr( - Call, - ), - ], - span: 1025..1034#0, - in_try: false, - }, - Member { - obj: Variable( - ( - "os", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "endianness", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 5, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, + Arrow, ), - Function( + ArrowExpr( Body, ), + BlockStmtOrExpr( + BlockStmt, + ), BlockStmt( Stmts( - 2, + 0, ), ), Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), + If, ), - VarDeclarator( - Init, + IfStmt( + Test, ), Expr( - Tpl, + Bin, ), - Tpl( - Exprs( - 2, - ), + BinExpr( + Right, ), Expr( - Call, - ), - CallExpr( - Callee, + Paren, ), - Callee( + ParenExpr( Expr, ), Expr( - Member, - ), - ], - span: 1038..1051#0, - in_try: false, - }, - MemberCall { - obj: Variable( - ( - "os", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "endianness", - ), - ), - ), - args: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 5, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), + Bin, ), - VarDeclarator( - Init, + BinExpr( + Right, ), Expr( - Tpl, + Bin, ), - Tpl( - Exprs( - 2, - ), + BinExpr( + Left, ), Expr( Call, ), ], - span: 1038..1053#0, + span: 2775..2800#0, in_try: false, }, - Member { - obj: Variable( - ( - "knownWindowsPackages", - #2, - ), - ), - prop: Variable( - ( - "platformKey", - #3, - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 5, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, + Conditional { + condition: Logical( + 18, + And, + [ + Logical( + 4, + Or, + [ + Not( + 2, + FreeVar( + "ESBUILD_BINARY_PATH", + ), + ), + Constant( + False, + ), + ], ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Member, - ), - ], - span: 1112..1145#0, - in_try: false, - }, - Member { - obj: Variable( - ( - "knownUnixlikePackages", - #2, - ), - ), - prop: Variable( - ( - "platformKey", - #3, - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 5, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Member, - ), - ], - span: 1239..1273#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "Error", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 5, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Throw, - ), - ThrowStmt( - Arg, - ), - Expr( - New, - ), - NewExpr( - Callee, - ), - Expr( - Ident, - ), - ], - span: 1329..1334#1, - in_try: false, - }, - FreeVar { - var: FreeVar( - "ESBUILD_BINARY_PATH", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Ident, - ), - ], - span: 1444..1463#1, - in_try: false, - }, - Conditional { - condition: FreeVar( - "ESBUILD_BINARY_PATH", - ), - kind: If { - then: EffectsBlock { - effects: [ - FreeVar { - var: FreeVar( - "ESBUILD_BINARY_PATH", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, + Logical( + 13, + Or, + [ + Binary( + 6, + MemberCall( + 4, + Variable( + ( + "path2", + #2, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Constant( + Str( + Atom( + "basename", + ), + ), ), + [ + FreeVar( + "__filename", + ), + ], + ), + StrictNotEqual, + Constant( + Str( + Word( + "main.js", + ), + ), + ), + ), + Binary( + 6, + MemberCall( + 4, + Variable( + ( + "path2", + #2, + ), + ), + Constant( + Str( + Atom( + "basename", + ), + ), + ), + [ + FreeVar( + "__dirname", + ), + ], + ), + StrictNotEqual, + Constant( + Str( + Word( + "lib", + ), + ), + ), + ), + ], + ), + ], + ), + kind: If { + then: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "Error", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, ), - Stmt( - If, - ), IfStmt( Cons, ), @@ -1004,52 +790,158 @@ ), ), Stmt( - Return, + Throw, ), - ReturnStmt( + ThrowStmt( Arg, ), + Expr( + New, + ), + NewExpr( + Callee, + ), Expr( Ident, ), ], - span: 1478..1497#1, + span: 2832..2837#1, + in_try: false, + }, + FreeVar { + var: FreeVar( + "__filename", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Throw, + ), + ThrowStmt( + Arg, + ), + Expr( + New, + ), + NewExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Tpl, + ), + Tpl( + Exprs( + 0, + ), + ), + Expr( + Ident, + ), + ], + span: 3047..3057#1, in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 7, + ), ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, }, ast_path: [ @@ -1058,21 +950,32 @@ ), Script( Body( - 6, + 7, ), ), Stmt( Decl, ), Decl( - Fn, + Var, ), - FnDecl( - Function, + VarDecl( + Decls( + 0, + ), ), - Function( + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( Body, ), + BlockStmtOrExpr( + BlockStmt, + ), BlockStmt( Stmts( 0, @@ -1085,3128 +988,568 @@ Test, ), ], - span: 1440..1502#0, + span: 2676..3489#0, in_try: false, }, - Call { - func: Variable( - ( - "pkgAndSubpathForCurrentPlatform", - #2, - ), + Conditional { + condition: Constant( + False, ), - args: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - ], - span: 1530..1563#0, - in_try: false, - }, - Member { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "resolve", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 1602..1617#0, - in_try: true, - }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 1602..1609#1, - in_try: true, - }, - MemberCall { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "resolve", - ), - ), - ), - args: [ - Value( - Concat( - 4, - [ - Variable( + kind: IfElse { + then: EffectsBlock { + effects: [ + Member { + obj: Variable( ( - "pkg", - #7, + "path2", + #2, ), ), - Constant( + prop: Constant( Str( Atom( - "/", + "join", ), ), ), - Variable( - ( - "subpath", - #7, + ast_path: [ + Program( + Script, ), - ), - ], - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Call, - ), - ], - span: 1602..1638#0, - in_try: true, - }, - FreeVar { - var: FreeVar( - "downloadedBinPath", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Ident, - ), - ], - span: 1670..1687#1, - in_try: false, - }, - Call { - func: FreeVar( - "downloadedBinPath", - ), - args: [ - Value( - Variable( - ( - "pkg", - #7, - ), - ), - ), - Value( - Variable( - ( - "subpath", - #7, - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Call, - ), - ], - span: 1670..1701#0, - in_try: false, - }, - Member { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "existsSync", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Unary, - ), - UnaryExpr( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 1712..1725#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "fs", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Unary, - ), - UnaryExpr( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 1712..1714#1, - in_try: false, - }, - MemberCall { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "existsSync", - ), - ), - ), - args: [ - Value( - Variable( - ( - "binPath", - #7, - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Unary, - ), - UnaryExpr( - Arg, - ), - Expr( - Call, - ), - ], - span: 1712..1734#0, - in_try: false, - }, - Conditional { - condition: Not( - 5, - MemberCall( - 4, - FreeVar( - "fs", - ), - Constant( - Str( - Atom( - "existsSync", - ), - ), - ), - [ - Variable( - ( - "binPath", - #7, - ), - ), - ], - ), - ), - kind: If { - then: EffectsBlock { - effects: [ - Member { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "resolve", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 1758..1773#0, - in_try: true, - }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 1758..1765#1, - in_try: true, - }, - MemberCall { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "resolve", - ), - ), - ), - args: [ - Value( - Variable( - ( - "pkg", - #7, - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - ], - span: 1758..1778#0, - in_try: true, - }, - FreeVar { - var: FreeVar( - "Error", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Throw, - ), - ThrowStmt( - Arg, - ), - Expr( - New, - ), - NewExpr( - Callee, - ), - Expr( - Ident, - ), - ], - span: 1814..1819#1, - in_try: false, - }, - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], - }, - }, - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 3, - ), - ), - Stmt( - Try, - ), - TryStmt( - Handler, - ), - CatchClause( - Body, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - ], - span: 1707..2154#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 5, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Ident, - ), - ], - span: 2196..2203#1, - in_try: true, - }, - Call { - func: FreeVar( - "require", - ), - args: [ - Value( - Constant( - Str( - Word( - "pnpapi", - ), - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 5, - ), - ), - Stmt( - Try, - ), - TryStmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - ], - span: 2196..2213#0, - in_try: true, - }, - Conditional { - condition: Variable( - ( - "isYarnPnP", - #7, - ), - ), - kind: If { - then: EffectsBlock { - effects: [ - Member { - obj: Variable( - ( - "path", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "dirname", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2299..2311#0, - in_try: false, - }, - Member { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "resolve", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2312..2327#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 2312..2319#1, - in_try: false, - }, - MemberCall { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "resolve", - ), - ), - ), - args: [ - Value( - Constant( - Str( - Word( - "esbuild", - ), - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Call, - ), - ], - span: 2312..2338#0, - in_try: false, - }, - MemberCall { - obj: Variable( - ( - "path", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "dirname", - ), - ), - ), - args: [ - Value( - MemberCall( - 4, - FreeVar( - "require", - ), - Constant( - Str( - Atom( - "resolve", - ), - ), - ), - [ - Constant( - Str( - Word( - "esbuild", - ), - ), - ), - ], - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - ], - span: 2299..2339#0, - in_try: false, - }, - Member { - obj: Variable( - ( - "path", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "join", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2367..2376#0, - in_try: false, - }, - Member { - obj: Variable( - ( - "path", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "basename", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 1, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Tpl, - ), - Tpl( - Exprs( - 1, - ), - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2422..2435#0, - in_try: false, - }, - MemberCall { - obj: Variable( - ( - "path", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "basename", - ), - ), - ), - args: [ - Value( - Variable( - ( - "subpath", - #7, - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Args( - 1, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Tpl, - ), - Tpl( - Exprs( - 1, - ), - ), - Expr( - Call, - ), - ], - span: 2422..2444#0, - in_try: false, - }, - MemberCall { - obj: Variable( - ( - "path", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "join", - ), - ), - ), - args: [ - Value( - Variable( - ( - "esbuildLibDir", - #16, - ), - ), - ), - Value( - Concat( - 8, - [ - Constant( - Str( - Atom( - "pnpapi-", - ), - ), - ), - Variable( - ( - "pkg", - #7, - ), - ), - Constant( - Str( - Atom( - "-", - ), - ), - ), - MemberCall( - 4, - Variable( - ( - "path", - #2, - ), - ), - Constant( - Str( - Atom( - "basename", - ), - ), - ), - [ - Variable( - ( - "subpath", - #7, - ), - ), - ], - ), - ], - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - ], - span: 2367..2452#0, - in_try: false, - }, - Member { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "existsSync", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Unary, - ), - UnaryExpr( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2463..2476#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "fs", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Unary, - ), - UnaryExpr( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 2463..2465#1, - in_try: false, - }, - MemberCall { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "existsSync", - ), - ), - ), - args: [ - Value( - Variable( - ( - "binTargetPath", - #16, - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Unary, - ), - UnaryExpr( - Arg, - ), - Expr( - Call, - ), - ], - span: 2463..2491#0, - in_try: false, - }, - Conditional { - condition: Not( - 5, - MemberCall( - 4, - FreeVar( - "fs", - ), - Constant( - Str( - Atom( - "existsSync", - ), - ), - ), - [ - Variable( - ( - "binTargetPath", - #16, - ), - ), - ], - ), - ), - kind: If { - then: EffectsBlock { - effects: [ - Member { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "copyFileSync", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2501..2516#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "fs", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 2501..2503#1, - in_try: false, - }, - MemberCall { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "copyFileSync", - ), - ), - ), - args: [ - Value( - Variable( - ( - "binPath", - #7, - ), - ), - ), - Value( - Variable( - ( - "binTargetPath", - #16, - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - ], - span: 2501..2540#0, - in_try: false, - }, - Member { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "chmodSync", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 2548..2560#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "fs", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), - ], - span: 2548..2550#1, - in_try: false, - }, - MemberCall { - obj: FreeVar( - "fs", - ), - prop: Constant( - Str( - Atom( - "chmodSync", - ), - ), - ), - args: [ - Value( - Variable( - ( - "binTargetPath", - #16, - ), - ), - ), - Value( - Constant( - Num( - ConstantNumber( - 493.0, - ), - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, - ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - ], - span: 2548..2580#0, - in_try: false, - }, - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 6, + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 1, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 3526..3536#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "__dirname", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 1, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Ident, + ), + ], + span: 3537..3546#1, + in_try: false, + }, + MemberCall { + obj: Variable( + ( + "path2", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "join", + ), + ), + ), + args: [ + Value( + FreeVar( + "__dirname", + ), + ), + Value( + Constant( + Str( + Word( + "..", ), ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, + ), + ), + Value( + Constant( + Str( + Word( + "bin", ), ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 2, + ), + ), + Value( + Constant( + Str( + Word( + "esbuild", ), ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], - }, - }, + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 1, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + ], + span: 3526..3571#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + else: EffectsBlock { + effects: [ + Call { + func: Variable( + ( + "generateBinPath", + #2, + ), + ), + args: [], ast_path: [ Program( Script, ), Script( Body( - 6, + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Array, + ), + ArrayLit( + Elems( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + ], + span: 3589..3606#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, ), ), Stmt( Decl, ), Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, + Var, ), - BlockStmt( - Stmts( - 6, + VarDecl( + Decls( + 0, ), ), - Stmt( - If, + VarDeclarator( + Init, ), - IfStmt( - Cons, + Expr( + Arrow, ), - Stmt( - Block, + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, ), BlockStmt( Stmts( @@ -4214,58 +1557,540 @@ ), ), Stmt( - If, - ), - IfStmt( - Test, + Return, ), ], - span: 2458..2587#0, - in_try: false, }, ], - ast_path: [ - Program( - Script, + range: StartAfter( + [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 3492..3578#0, + in_try: false, + }, + Call { + func: Variable( + ( + "esbuildCommandAndArgs", + #2, + ), + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 8, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 3638..3661#0, + in_try: false, + }, + Member { + obj: Variable( + ( + "args", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "concat", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 9, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 3671..3682#0, + in_try: false, + }, + MemberCall { + obj: Variable( + ( + "args", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "concat", + ), + ), + ), + args: [ + Value( + Constant( + Str( + RcStr( + "--service=0.14.12", + ), ), - Script( - Body( - 6, + ), + ), + Value( + Constant( + Str( + Word( + "--ping", + ), + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 9, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 3671..3718#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "require", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 12..19#1, + in_try: false, + }, + Call { + func: FreeVar( + "require", + ), + args: [ + Value( + Constant( + Str( + Word( + "path", ), ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 6, + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 12..27#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "require", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 41..48#1, + in_try: false, + }, + Call { + func: FreeVar( + "require", + ), + args: [ + Value( + Constant( + Str( + Word( + "path", ), ), - Stmt( - If, - ), - IfStmt( - Cons, + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 41..56#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "require", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 67..74#1, + in_try: false, + }, + Call { + func: FreeVar( + "require", + ), + args: [ + Value( + Constant( + Str( + Word( + "os", + ), ), - ], - }, - }, + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 67..80#0, + in_try: false, + }, + Member { + obj: FreeVar( + "process", + ), + prop: Constant( + Str( + Atom( + "platform", + ), + ), + ), ast_path: [ Program( Script, ), Script( Body( - 6, + 5, ), ), Stmt( @@ -4282,22 +2107,41 @@ ), BlockStmt( Stmts( - 6, + 2, ), ), Stmt( - If, + Decl, ), - IfStmt( - Test, + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Tpl, + ), + Tpl( + Exprs( + 0, + ), + ), + Expr( + Member, ), ], - span: 2256..2617#0, + span: 1005..1021#0, in_try: false, }, FreeVar { var: FreeVar( - "ESBUILD_BINARY_PATH", + "process", ), ast_path: [ Program( @@ -4305,7 +2149,24 @@ ), Script( Body( - 7, + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, ), ), Stmt( @@ -4323,77 +2184,143 @@ Init, ), Expr( - Arrow, + Tpl, ), - ArrowExpr( - Body, + Tpl( + Exprs( + 0, + ), ), - BlockStmtOrExpr( - BlockStmt, + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 1005..1012#1, + in_try: false, + }, + Member { + obj: Variable( + ( + "os", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "arch", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, ), BlockStmt( Stmts( - 0, + 2, ), ), Stmt( - If, + Decl, ), - IfStmt( - Test, + Decl( + Var, ), - Expr( - Bin, + VarDecl( + Decls( + 0, + ), ), - BinExpr( - Left, + VarDeclarator( + Init, ), Expr( - Paren, + Tpl, ), - ParenExpr( - Expr, + Tpl( + Exprs( + 1, + ), ), Expr( - Bin, - ), - BinExpr( - Left, + Call, ), - Expr( - Unary, + CallExpr( + Callee, ), - UnaryExpr( - Arg, + Callee( + Expr, ), Expr( - Ident, + Member, ), ], - span: 2687..2706#1, + span: 1025..1032#0, in_try: false, }, - Member { + MemberCall { obj: Variable( ( - "path2", + "os", #2, ), ), prop: Constant( Str( Atom( - "basename", + "arch", ), ), ), + args: [], ast_path: [ Program( Script, ), Script( Body( - 7, + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, ), ), Stmt( @@ -4411,48 +2338,81 @@ Init, ), Expr( - Arrow, + Tpl, ), - ArrowExpr( - Body, + Tpl( + Exprs( + 1, + ), ), - BlockStmtOrExpr( - BlockStmt, + Expr( + Call, + ), + ], + span: 1025..1034#0, + in_try: false, + }, + Member { + obj: Variable( + ( + "os", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "endianness", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, ), BlockStmt( Stmts( - 0, + 2, ), ), Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Bin, - ), - BinExpr( - Right, - ), - Expr( - Paren, + Decl, ), - ParenExpr( - Expr, + Decl( + Var, ), - Expr( - Bin, + VarDecl( + Decls( + 0, + ), ), - BinExpr( - Left, + VarDeclarator( + Init, ), Expr( - Bin, + Tpl, ), - BinExpr( - Left, + Tpl( + Exprs( + 2, + ), ), Expr( Call, @@ -4467,205 +2427,162 @@ Member, ), ], - span: 2725..2739#0, + span: 1038..1051#0, in_try: false, }, - FreeVar { - var: FreeVar( - "__filename", + MemberCall { + obj: Variable( + ( + "os", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "endianness", + ), + ), ), + args: [], ast_path: [ Program( Script, ), Script( Body( - 7, + 5, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 0, + 2, ), ), Stmt( - If, - ), - IfStmt( - Test, - ), - Expr( - Bin, - ), - BinExpr( - Right, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Bin, + Decl, ), - BinExpr( - Left, + Decl( + Var, ), - Expr( - Bin, + VarDecl( + Decls( + 0, + ), ), - BinExpr( - Left, + VarDeclarator( + Init, ), Expr( - Call, + Tpl, ), - CallExpr( - Args( - 0, + Tpl( + Exprs( + 2, ), ), - ExprOrSpread( - Expr, - ), Expr( - Ident, + Call, ), ], - span: 2740..2750#1, + span: 1038..1053#0, in_try: false, }, - MemberCall { + Member { obj: Variable( ( - "path2", + "knownWindowsPackages", #2, ), ), - prop: Constant( - Str( - Atom( - "basename", - ), + prop: Variable( + ( + "platformKey", + #3, ), ), - args: [ - Value( - FreeVar( - "__filename", - ), - ), - ], ast_path: [ Program( Script, ), Script( Body( - 7, + 5, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 0, + 3, ), ), Stmt( If, ), IfStmt( - Test, - ), - Expr( - Bin, + Cons, ), - BinExpr( - Right, + Stmt( + Block, ), - Expr( - Paren, + BlockStmt( + Stmts( + 0, + ), ), - ParenExpr( + Stmt( Expr, ), - Expr( - Bin, - ), - BinExpr( - Left, + ExprStmt( + Expr, ), Expr( - Bin, + Assign, ), - BinExpr( - Left, + AssignExpr( + Right, ), Expr( - Call, + Member, ), ], - span: 2725..2751#0, + span: 1112..1145#0, in_try: false, }, Member { obj: Variable( ( - "path2", + "knownUnixlikePackages", #2, ), ), - prop: Constant( - Str( - Atom( - "basename", - ), + prop: Variable( + ( + "platformKey", + #3, ), ), ast_path: [ @@ -4674,86 +2591,68 @@ ), Script( Body( - 7, + 5, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 0, + 3, ), ), Stmt( If, ), - IfStmt( - Test, - ), - Expr( - Bin, - ), - BinExpr( - Right, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Bin, + IfStmt( + Alt, ), - BinExpr( - Right, + Stmt( + If, ), - Expr( - Bin, + IfStmt( + Cons, ), - BinExpr( - Left, + Stmt( + Block, ), - Expr( - Call, + BlockStmt( + Stmts( + 0, + ), ), - CallExpr( - Callee, + Stmt( + Expr, ), - Callee( + ExprStmt( Expr, ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), Expr( Member, ), ], - span: 2775..2789#0, + span: 1239..1273#0, in_try: false, }, FreeVar { var: FreeVar( - "__dirname", + "Error", ), ast_path: [ Program( @@ -4761,138 +2660,122 @@ ), Script( Body( - 7, + 5, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 0, + 3, ), ), Stmt( If, ), IfStmt( - Test, - ), - Expr( - Bin, - ), - BinExpr( - Right, + Alt, ), - Expr( - Paren, + Stmt( + If, ), - ParenExpr( - Expr, + IfStmt( + Alt, ), - Expr( - Bin, + Stmt( + Block, ), - BinExpr( - Right, + BlockStmt( + Stmts( + 0, + ), ), - Expr( - Bin, + Stmt( + Throw, ), - BinExpr( - Left, + ThrowStmt( + Arg, ), Expr( - Call, - ), - CallExpr( - Args( - 0, - ), + New, ), - ExprOrSpread( - Expr, + NewExpr( + Callee, ), Expr( Ident, ), ], - span: 2790..2799#1, + span: 1329..1334#1, in_try: false, }, - MemberCall { - obj: Variable( - ( - "path2", - #2, + Unreachable { + start_ast_path: [ + Program( + Script, ), - ), - prop: Constant( - Str( - Atom( - "basename", + Script( + Body( + 5, ), ), - ), - args: [ - Value( - FreeVar( - "__dirname", + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 4, ), ), + Stmt( + Return, + ), ], + }, + FreeVar { + var: FreeVar( + "ESBUILD_BINARY_PATH", + ), ast_path: [ Program( Script, ), Script( Body( - 7, + 6, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( 0, @@ -4905,406 +2788,1370 @@ Test, ), Expr( - Bin, - ), - BinExpr( - Right, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Bin, - ), - BinExpr( - Right, - ), - Expr( - Bin, - ), - BinExpr( - Left, - ), - Expr( - Call, + Ident, ), ], - span: 2775..2800#0, + span: 1444..1463#1, in_try: false, }, Conditional { - condition: Logical( - 18, - And, - [ - Logical( - 4, - Or, + condition: FreeVar( + "ESBUILD_BINARY_PATH", + ), + kind: IfElse { + then: EffectsBlock { + effects: [ + FreeVar { + var: FreeVar( + "ESBUILD_BINARY_PATH", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Ident, + ), + ], + span: 1478..1497#1, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( [ - Not( - 2, - FreeVar( - "ESBUILD_BINARY_PATH", + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + else: EffectsBlock { + effects: [ + Call { + func: Variable( + ( + "pkgAndSubpathForCurrentPlatform", + #2, + ), + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 1530..1563#0, + in_try: false, + }, + Member { + obj: FreeVar( + "require", + ), + prop: Constant( + Str( + Atom( + "resolve", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 1602..1617#0, + in_try: true, + }, + FreeVar { + var: FreeVar( + "require", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 1602..1609#1, + in_try: true, + }, + MemberCall { + obj: FreeVar( + "require", + ), + prop: Constant( + Str( + Atom( + "resolve", + ), + ), + ), + args: [ + Value( + Concat( + 4, + [ + Variable( + ( + "pkg", + #7, + ), + ), + Constant( + Str( + Atom( + "/", + ), + ), + ), + Variable( + ( + "subpath", + #7, + ), + ), + ], + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Call, + ), + ], + span: 1602..1638#0, + in_try: true, + }, + FreeVar { + var: FreeVar( + "downloadedBinPath", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 1670..1687#1, + in_try: false, + }, + Call { + func: FreeVar( + "downloadedBinPath", + ), + args: [ + Value( + Variable( + ( + "pkg", + #7, + ), + ), + ), + Value( + Variable( + ( + "subpath", + #7, + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Call, + ), + ], + span: 1670..1701#0, + in_try: false, + }, + Member { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "existsSync", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 1712..1725#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "fs", ), - Constant( - False, + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 1712..1714#1, + in_try: false, + }, + MemberCall { + obj: FreeVar( + "fs", ), - ], - ), - Logical( - 13, - Or, - [ - Binary( - 6, - MemberCall( - 4, + prop: Constant( + Str( + Atom( + "existsSync", + ), + ), + ), + args: [ + Value( Variable( ( - "path2", - #2, + "binPath", + #7, ), ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), + Expr( + Call, + ), + ], + span: 1712..1734#0, + in_try: false, + }, + Conditional { + condition: Not( + 5, + MemberCall( + 4, + FreeVar( + "fs", + ), Constant( Str( Atom( - "basename", + "existsSync", + ), + ), + ), + [ + Variable( + ( + "binPath", + #7, + ), + ), + ], + ), + ), + kind: If { + then: EffectsBlock { + effects: [ + Member { + obj: FreeVar( + "require", + ), + prop: Constant( + Str( + Atom( + "resolve", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 1758..1773#0, + in_try: true, + }, + FreeVar { + var: FreeVar( + "require", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 1758..1765#1, + in_try: true, + }, + MemberCall { + obj: FreeVar( + "require", + ), + prop: Constant( + Str( + Atom( + "resolve", + ), + ), + ), + args: [ + Value( + Variable( + ( + "pkg", + #7, + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 1758..1778#0, + in_try: true, + }, + FreeVar { + var: FreeVar( + "Error", ), - ), - ), - [ - FreeVar( - "__filename", - ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Throw, + ), + ThrowStmt( + Arg, + ), + Expr( + New, + ), + NewExpr( + Callee, + ), + Expr( + Ident, + ), + ], + span: 1814..1819#1, + in_try: false, + }, ], - ), - StrictNotEqual, - Constant( - Str( - Word( - "main.js", - ), - ), - ), - ), - Binary( - 6, - MemberCall( - 4, - Variable( - ( - "path2", - #2, - ), - ), - Constant( - Str( - Atom( - "basename", + range: Exact( + [ + Program( + Script, ), - ), - ), - [ - FreeVar( - "__dirname", - ), - ], - ), - StrictNotEqual, - Constant( - Str( - Word( - "lib", - ), - ), - ), - ), - ], - ), - ], - ), - kind: If { - then: EffectsBlock { - effects: [ - FreeVar { - var: FreeVar( - "Error", - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 7, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], ), - ), - Stmt( - Throw, - ), - ThrowStmt( - Arg, - ), - Expr( - New, - ), - NewExpr( - Callee, - ), - Expr( - Ident, - ), - ], - span: 2832..2837#1, - in_try: false, - }, - FreeVar { - var: FreeVar( - "__filename", - ), + }, + }, ast_path: [ Program( Script, ), Script( Body( - 7, + 6, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - If, + Fn, ), - IfStmt( - Cons, + FnDecl( + Function, ), - Stmt( - Block, + Function( + Body, ), BlockStmt( Stmts( - 0, + 3, ), ), Stmt( - Throw, + Try, ), - ThrowStmt( - Arg, + TryStmt( + Handler, ), - Expr( - New, + CatchClause( + Body, ), - NewExpr( - Args( - 0, + BlockStmt( + Stmts( + 1, ), ), - ExprOrSpread( - Expr, - ), - Expr( - Tpl, - ), - Tpl( - Exprs( - 0, - ), + Stmt( + If, ), - Expr( - Ident, + IfStmt( + Test, ), ], - span: 3047..3057#1, + span: 1707..2154#0, in_try: false, }, - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 7, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], - }, - }, - ast_path: [ - Program( - Script, - ), - Script( - Body( - 7, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - If, - ), - IfStmt( - Test, - ), - ], - span: 2676..3489#0, - in_try: false, - }, - Conditional { - condition: Constant( - False, - ), - kind: If { - then: EffectsBlock { - effects: [ - Member { - obj: Variable( - ( - "path2", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "join", - ), - ), + FreeVar { + var: FreeVar( + "require", ), ast_path: [ Program( @@ -5312,44 +4159,30 @@ ), Script( Body( - 7, + 6, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 1, + 5, ), ), Stmt( - If, - ), - IfStmt( - Cons, + Try, ), - Stmt( + TryStmt( Block, ), BlockStmt( @@ -5358,31 +4191,9 @@ ), ), Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Array, - ), - ArrayLit( - Elems( - 1, - ), - ), - ExprOrSpread( Expr, ), - Expr( - Array, - ), - ArrayLit( - Elems( - 0, - ), - ), - ExprOrSpread( + ExprStmt( Expr, ), Expr( @@ -5395,292 +4206,2103 @@ Expr, ), Expr( - Member, + Ident, ), ], - span: 3526..3536#0, - in_try: false, + span: 2196..2203#1, + in_try: true, }, - FreeVar { - var: FreeVar( - "__dirname", + Call { + func: FreeVar( + "require", ), + args: [ + Value( + Constant( + Str( + Word( + "pnpapi", + ), + ), + ), + ), + ], ast_path: [ Program( Script, ), Script( Body( - 7, + 6, ), ), Stmt( Decl, ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Array, - ), - ArrayLit( - Elems( - 1, - ), + Decl( + Fn, ), - ExprOrSpread( - Expr, + FnDecl( + Function, ), - Expr( - Array, + Function( + Body, ), - ArrayLit( - Elems( - 0, + BlockStmt( + Stmts( + 5, ), ), - ExprOrSpread( - Expr, + Stmt( + Try, ), - Expr( - Call, + TryStmt( + Block, ), - CallExpr( - Args( + BlockStmt( + Stmts( 0, ), ), - ExprOrSpread( + Stmt( + Expr, + ), + ExprStmt( Expr, ), Expr( - Ident, + Call, ), ], - span: 3537..3546#1, - in_try: false, + span: 2196..2213#0, + in_try: true, }, - MemberCall { - obj: Variable( + Conditional { + condition: Variable( ( - "path2", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "join", - ), + "isYarnPnP", + #7, ), ), - args: [ - Value( - FreeVar( - "__dirname", - ), - ), - Value( - Constant( - Str( - Word( - "..", + kind: IfElse { + then: EffectsBlock { + effects: [ + Member { + obj: Variable( + ( + "path", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "dirname", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2299..2311#0, + in_try: false, + }, + Member { + obj: FreeVar( + "require", + ), + prop: Constant( + Str( + Atom( + "resolve", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2312..2327#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "require", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 2312..2319#1, + in_try: false, + }, + MemberCall { + obj: FreeVar( + "require", + ), + prop: Constant( + Str( + Atom( + "resolve", + ), + ), + ), + args: [ + Value( + Constant( + Str( + Word( + "esbuild", + ), + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Call, + ), + ], + span: 2312..2338#0, + in_try: false, + }, + MemberCall { + obj: Variable( + ( + "path", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "dirname", + ), + ), + ), + args: [ + Value( + MemberCall( + 4, + FreeVar( + "require", + ), + Constant( + Str( + Atom( + "resolve", + ), + ), + ), + [ + Constant( + Str( + Word( + "esbuild", + ), + ), + ), + ], + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 2299..2339#0, + in_try: false, + }, + Member { + obj: Variable( + ( + "path", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "join", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2367..2376#0, + in_try: false, + }, + Member { + obj: Variable( + ( + "path", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "basename", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 1, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Tpl, + ), + Tpl( + Exprs( + 1, + ), + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2422..2435#0, + in_try: false, + }, + MemberCall { + obj: Variable( + ( + "path", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "basename", + ), + ), + ), + args: [ + Value( + Variable( + ( + "subpath", + #7, + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + CallExpr( + Args( + 1, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Tpl, + ), + Tpl( + Exprs( + 1, + ), + ), + Expr( + Call, + ), + ], + span: 2422..2444#0, + in_try: false, + }, + MemberCall { + obj: Variable( + ( + "path", + #2, + ), + ), + prop: Constant( + Str( + Atom( + "join", + ), + ), + ), + args: [ + Value( + Variable( + ( + "esbuildLibDir", + #16, + ), + ), + ), + Value( + Concat( + 8, + [ + Constant( + Str( + Atom( + "pnpapi-", + ), + ), + ), + Variable( + ( + "pkg", + #7, + ), + ), + Constant( + Str( + Atom( + "-", + ), + ), + ), + MemberCall( + 4, + Variable( + ( + "path", + #2, + ), + ), + Constant( + Str( + Atom( + "basename", + ), + ), + ), + [ + Variable( + ( + "subpath", + #7, + ), + ), + ], + ), + ], + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 2367..2452#0, + in_try: false, + }, + Member { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "existsSync", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2463..2476#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "fs", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 2463..2465#1, + in_try: false, + }, + MemberCall { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "existsSync", + ), + ), + ), + args: [ + Value( + Variable( + ( + "binTargetPath", + #16, + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + Expr( + Unary, + ), + UnaryExpr( + Arg, + ), + Expr( + Call, + ), + ], + span: 2463..2491#0, + in_try: false, + }, + Conditional { + condition: Not( + 5, + MemberCall( + 4, + FreeVar( + "fs", + ), + Constant( + Str( + Atom( + "existsSync", + ), + ), + ), + [ + Variable( + ( + "binTargetPath", + #16, + ), + ), + ], + ), + ), + kind: If { + then: EffectsBlock { + effects: [ + Member { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "copyFileSync", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2501..2516#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "fs", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 2501..2503#1, + in_try: false, + }, + MemberCall { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "copyFileSync", + ), + ), + ), + args: [ + Value( + Variable( + ( + "binPath", + #7, + ), + ), + ), + Value( + Variable( + ( + "binTargetPath", + #16, + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 2501..2540#0, + in_try: false, + }, + Member { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "chmodSync", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + ], + span: 2548..2560#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "fs", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 2548..2550#1, + in_try: false, + }, + MemberCall { + obj: FreeVar( + "fs", + ), + prop: Constant( + Str( + Atom( + "chmodSync", + ), + ), + ), + args: [ + Value( + Variable( + ( + "binTargetPath", + #16, + ), + ), + ), + Value( + Constant( + Num( + ConstantNumber( + 493.0, + ), + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 2548..2580#0, + in_try: false, + }, + ], + range: Exact( + [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + If, + ), + IfStmt( + Test, + ), + ], + span: 2458..2587#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Script, ), - ), - ), - ), - Value( - Constant( - Str( - Word( - "bin", + Script( + Body( + 6, + ), ), - ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], ), - ), - Value( - Constant( - Str( - Word( - "esbuild", + }, + else: EffectsBlock { + effects: [ + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: StartAfter( + [ + Program( + Script, ), - ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 6, + ), + ), + Stmt( + If, + ), + ], ), - ), - ], + }, + }, ast_path: [ Program( Script, ), Script( Body( - 7, + 6, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 1, + 6, ), ), Stmt( If, ), IfStmt( - Cons, - ), - Stmt( - Block, - ), - BlockStmt( - Stmts( - 0, - ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Array, - ), - ArrayLit( - Elems( - 1, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Array, - ), - ArrayLit( - Elems( - 0, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Call, + Test, ), ], - span: 3526..3571#0, + span: 2256..2617#0, in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 7, + range: StartAfter( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 1, + BlockStmt( + Stmts( + 0, + ), ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Stmt( + If, + ), + ], + ), }, }, ast_path: [ @@ -5689,35 +6311,24 @@ ), Script( Body( - 7, + 6, ), ), Stmt( Decl, ), Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, + Fn, ), - Expr( - Arrow, + FnDecl( + Function, ), - ArrowExpr( + Function( Body, ), - BlockStmtOrExpr( - BlockStmt, - ), BlockStmt( Stmts( - 1, + 0, ), ), Stmt( @@ -5727,231 +6338,7 @@ Test, ), ], - span: 3492..3578#0, - in_try: false, - }, - Call { - func: Variable( - ( - "generateBinPath", - #2, - ), - ), - args: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 7, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 2, - ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Array, - ), - ArrayLit( - Elems( - 0, - ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Call, - ), - ], - span: 3589..3606#0, - in_try: false, - }, - Call { - func: Variable( - ( - "esbuildCommandAndArgs", - #2, - ), - ), - args: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 8, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - ], - span: 3638..3661#0, - in_try: false, - }, - Member { - obj: Variable( - ( - "args", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "concat", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 9, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - ], - span: 3671..3682#0, - in_try: false, - }, - MemberCall { - obj: Variable( - ( - "args", - #2, - ), - ), - prop: Constant( - Str( - Atom( - "concat", - ), - ), - ), - args: [ - Value( - Constant( - Str( - RcStr( - "--service=0.14.12", - ), - ), - ), - ), - Value( - Constant( - Str( - Word( - "--ping", - ), - ), - ), - ), - ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 9, - ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, - ), - ), - VarDeclarator( - Init, - ), - Expr( - Call, - ), - ], - span: 3671..3718#0, + span: 1440..1502#0, in_try: false, }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot index e6876bcfb98e6..f5649bfa66dc2 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/esbuild/resolved-effects.snapshot @@ -1,42 +1,116 @@ -0 -> 1 free var = FreeVar(require) +0 -> 1 free var = FreeVar(ESBUILD_BINARY_PATH) -0 -> 2 call = require*0*("path") +0 -> 3 free var = FreeVar(__filename) + +0 -> 4 member call = path*0*["basename"]("__filename") +- *0* path: The Node.js path module: https://nodejs.org/api/path.html + +0 -> 6 free var = FreeVar(__dirname) + +0 -> 7 member call = path*0*["basename"]("__dirname") +- *0* path: The Node.js path module: https://nodejs.org/api/path.html + +0 -> 8 conditional = (!(???*0*) | false | (???*1* !== "main.js") | (???*4* !== "lib")) +- *0* FreeVar(ESBUILD_BINARY_PATH) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* ???*2*("__filename") + ⚠️ unknown callee + ⚠️ This value might have side effects +- *2* path*3*["basename"] + ⚠️ unsupported property on Node.js path module + ⚠️ This value might have side effects +- *3* path: The Node.js path module: https://nodejs.org/api/path.html +- *4* ???*5*("__dirname") + ⚠️ unknown callee + ⚠️ This value might have side effects +- *5* path*6*["basename"] + ⚠️ unsupported property on Node.js path module + ⚠️ This value might have side effects +- *6* path: The Node.js path module: https://nodejs.org/api/path.html + +8 -> 9 free var = FreeVar(Error) + +8 -> 10 free var = FreeVar(__filename) + +0 -> 11 conditional = false + +11 -> 13 free var = FreeVar(__dirname) + +11 -> 14 member call = path*0*["join"]("__dirname", "..", "bin", "esbuild") +- *0* path: The Node.js path module: https://nodejs.org/api/path.html + +11 -> 15 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +11 -> 16 call = (...) => (FreeVar(ESBUILD_BINARY_PATH) | binTargetPath | binPath)() + +11 -> 17 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 18 call = (...) => ( + | [ + "node", + [ + path2["join"](FreeVar(__dirname), "..", "bin", "esbuild") + ] + ] + | [generateBinPath(), []] +)() + +0 -> 20 member call = ???*0*["concat"]("--service=0.14.12", "--ping") +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 21 free var = FreeVar(require) + +0 -> 22 call = require*0*("path") - *0* require: The require method from CommonJS -0 -> 3 free var = FreeVar(require) +0 -> 23 free var = FreeVar(require) -0 -> 4 call = require*0*("path") +0 -> 24 call = require*0*("path") - *0* require: The require method from CommonJS -0 -> 5 free var = FreeVar(require) +0 -> 25 free var = FreeVar(require) -0 -> 6 call = require*0*("os") +0 -> 26 call = require*0*("os") - *0* require: The require method from CommonJS -0 -> 8 free var = FreeVar(process) +0 -> 28 free var = FreeVar(process) -0 -> 10 member call = os*0*["arch"]() +0 -> 30 member call = os*0*["arch"]() - *0* os: The Node.js os module: https://nodejs.org/api/os.html -0 -> 12 member call = os*0*["endianness"]() +0 -> 32 member call = os*0*["endianness"]() - *0* os: The Node.js os module: https://nodejs.org/api/os.html -0 -> 15 free var = FreeVar(Error) +0 -> 35 free var = FreeVar(Error) + +0 -> 36 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 16 free var = FreeVar(ESBUILD_BINARY_PATH) +0 -> 37 free var = FreeVar(ESBUILD_BINARY_PATH) -0 -> 17 conditional = ???*0* +0 -> 38 conditional = ???*0* - *0* FreeVar(ESBUILD_BINARY_PATH) ⚠️ unknown global ⚠️ This value might have side effects -17 -> 18 free var = FreeVar(ESBUILD_BINARY_PATH) +38 -> 39 free var = FreeVar(ESBUILD_BINARY_PATH) -0 -> 19 call = (...) => {"pkg": pkg, "subpath": subpath}() +38 -> 40 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 21 free var = FreeVar(require) +38 -> 41 call = (...) => {"pkg": pkg, "subpath": subpath}() -0 -> 22 member call = require*0*["resolve"]( +38 -> 43 free var = FreeVar(require) + +38 -> 44 member call = require*0*["resolve"]( `${(???*1* | ???*2* | ???*3* | "esbuild-linux-64")}/${(???*4* | "esbuild.exe" | "bin/esbuild" | ???*5*)}` ) - *0* require: The require method from CommonJS @@ -52,9 +126,9 @@ - *5* unknown mutation ⚠️ This value might have side effects -0 -> 23 free var = FreeVar(downloadedBinPath) +38 -> 45 free var = FreeVar(downloadedBinPath) -0 -> 24 call = ???*0*((???*1* | ???*2* | ???*3* | "esbuild-linux-64"), (???*4* | "esbuild.exe" | "bin/esbuild" | ???*5*)) +38 -> 46 call = ???*0*((???*1* | ???*2* | ???*3* | "esbuild-linux-64"), (???*4* | "esbuild.exe" | "bin/esbuild" | ???*5*)) - *0* FreeVar(downloadedBinPath) ⚠️ unknown global ⚠️ This value might have side effects @@ -70,9 +144,9 @@ - *5* unknown mutation ⚠️ This value might have side effects -0 -> 26 free var = FreeVar(fs) +38 -> 48 free var = FreeVar(fs) -0 -> 27 member call = ???*0*["existsSync"]((???*1* | ???*2* | ???*9*)) +38 -> 49 member call = ???*0*["existsSync"]((???*1* | ???*2* | ???*9*)) - *0* FreeVar(fs) ⚠️ unknown global ⚠️ This value might have side effects @@ -102,7 +176,7 @@ ⚠️ unknown global ⚠️ This value might have side effects -0 -> 28 conditional = !(???*0*) +38 -> 50 conditional = !(???*0*) - *0* ???*1*["existsSync"](binPath) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -110,9 +184,9 @@ ⚠️ unknown global ⚠️ This value might have side effects -28 -> 30 free var = FreeVar(require) +50 -> 52 free var = FreeVar(require) -28 -> 31 member call = require*0*["resolve"]((???*1* | ???*2* | ???*3* | "esbuild-linux-64")) +50 -> 53 member call = require*0*["resolve"]((???*1* | ???*2* | ???*3* | "esbuild-linux-64")) - *0* require: The require method from CommonJS - *1* pkg ⚠️ pattern without value @@ -122,31 +196,31 @@ - *3* unknown mutation ⚠️ This value might have side effects -28 -> 32 free var = FreeVar(Error) +50 -> 54 free var = FreeVar(Error) -0 -> 33 free var = FreeVar(require) +38 -> 55 free var = FreeVar(require) -0 -> 34 call = require*0*("pnpapi") +38 -> 56 call = require*0*("pnpapi") - *0* require: The require method from CommonJS -0 -> 35 conditional = (false | true) +38 -> 57 conditional = (false | true) -35 -> 38 free var = FreeVar(require) +57 -> 60 free var = FreeVar(require) -35 -> 39 member call = require*0*["resolve"]("esbuild") +57 -> 61 member call = require*0*["resolve"]("esbuild") - *0* require: The require method from CommonJS -35 -> 40 member call = path*0*["dirname"]("\"esbuild\"/resolved/lib/index.js") +57 -> 62 member call = path*0*["dirname"]("\"esbuild\"/resolved/lib/index.js") - *0* path: The Node.js path module: https://nodejs.org/api/path.html -35 -> 43 member call = path*0*["basename"]((???*1* | "esbuild.exe" | "bin/esbuild" | ???*2*)) +57 -> 65 member call = path*0*["basename"]((???*1* | "esbuild.exe" | "bin/esbuild" | ???*2*)) - *0* path: The Node.js path module: https://nodejs.org/api/path.html - *1* subpath ⚠️ pattern without value - *2* unknown mutation ⚠️ This value might have side effects -35 -> 44 member call = path*0*["join"]( +57 -> 66 member call = path*0*["join"]( "\"esbuild\"/resolved/lib", `pnpapi-${(???*1* | ???*2* | ???*3* | "esbuild-linux-64")}-${???*4*}` ) @@ -170,9 +244,9 @@ - *8* unknown mutation ⚠️ This value might have side effects -35 -> 46 free var = FreeVar(fs) +57 -> 68 free var = FreeVar(fs) -35 -> 47 member call = ???*0*["existsSync"]( +57 -> 69 member call = ???*0*["existsSync"]( `"esbuild"/resolved/lib${("/" | "")}pnpapi-${(???*1* | ???*2* | ???*3* | "esbuild-linux-64")}-${???*4*}` ) - *0* FreeVar(fs) @@ -197,7 +271,7 @@ - *8* unknown mutation ⚠️ This value might have side effects -35 -> 48 conditional = !(???*0*) +57 -> 70 conditional = !(???*0*) - *0* ???*1*["existsSync"](binTargetPath) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -205,9 +279,9 @@ ⚠️ unknown global ⚠️ This value might have side effects -48 -> 50 free var = FreeVar(fs) +70 -> 72 free var = FreeVar(fs) -48 -> 51 member call = ???*0*["copyFileSync"]( +70 -> 73 member call = ???*0*["copyFileSync"]( (???*1* | ???*2* | ???*9*), `"esbuild"/resolved/lib${("/" | "")}pnpapi-${(???*11* | ???*12* | ???*13* | "esbuild-linux-64")}-${???*14*}` ) @@ -260,9 +334,9 @@ - *18* unknown mutation ⚠️ This value might have side effects -48 -> 53 free var = FreeVar(fs) +70 -> 75 free var = FreeVar(fs) -48 -> 54 member call = ???*0*["chmodSync"]( +70 -> 76 member call = ???*0*["chmodSync"]( `"esbuild"/resolved/lib${("/" | "")}pnpapi-${(???*1* | ???*2* | ???*3* | "esbuild-linux-64")}-${???*4*}`, 493 ) @@ -288,60 +362,10 @@ - *8* unknown mutation ⚠️ This value might have side effects -0 -> 55 free var = FreeVar(ESBUILD_BINARY_PATH) - -0 -> 57 free var = FreeVar(__filename) - -0 -> 58 member call = path*0*["basename"]("__filename") -- *0* path: The Node.js path module: https://nodejs.org/api/path.html - -0 -> 60 free var = FreeVar(__dirname) - -0 -> 61 member call = path*0*["basename"]("__dirname") -- *0* path: The Node.js path module: https://nodejs.org/api/path.html - -0 -> 62 conditional = (!(???*0*) | false | (???*1* !== "main.js") | (???*4* !== "lib")) -- *0* FreeVar(ESBUILD_BINARY_PATH) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* ???*2*("__filename") - ⚠️ unknown callee - ⚠️ This value might have side effects -- *2* path*3*["basename"] - ⚠️ unsupported property on Node.js path module +57 -> 77 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *3* path: The Node.js path module: https://nodejs.org/api/path.html -- *4* ???*5*("__dirname") - ⚠️ unknown callee - ⚠️ This value might have side effects -- *5* path*6*["basename"] - ⚠️ unsupported property on Node.js path module - ⚠️ This value might have side effects -- *6* path: The Node.js path module: https://nodejs.org/api/path.html - -62 -> 63 free var = FreeVar(Error) - -62 -> 64 free var = FreeVar(__filename) - -0 -> 65 conditional = false - -65 -> 67 free var = FreeVar(__dirname) - -65 -> 68 member call = path*0*["join"]("__dirname", "..", "bin", "esbuild") -- *0* path: The Node.js path module: https://nodejs.org/api/path.html -0 -> 69 call = (...) => (FreeVar(ESBUILD_BINARY_PATH) | binTargetPath | binPath)() - -0 -> 70 call = (...) => ( - | [ - "node", - [ - path2["join"](FreeVar(__dirname), "..", "bin", "esbuild") - ] - ] - | [generateBinPath(), []] -)() - -0 -> 72 member call = ???*0*["concat"]("--service=0.14.12", "--ping") -- *0* max number of linking steps reached +57 -> 78 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/graph-effects.snapshot index c62e42a42732e..6559fa298c1e6 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/graph-effects.snapshot @@ -56,4 +56,36 @@ span: 72..83#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/resolved-effects.snapshot index e0fdda9108171..eac04a77b02eb 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array-2/resolved-effects.snapshot @@ -1 +1,5 @@ 0 -> 1 call = (...) => [`${a}${x}`, a]("1", "2") + +0 -> 2 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/graph-effects.snapshot index ac8747e442c7a..c80d10979421d 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/graph-effects.snapshot @@ -56,4 +56,36 @@ span: 59..70#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/resolved-effects.snapshot index cefd31428c09c..d24c63756274b 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/fn-array/resolved-effects.snapshot @@ -1 +1,5 @@ 0 -> 1 call = (...) => [`${a}${b}`, a]("1", "2") + +0 -> 2 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/iife/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/iife/graph-effects.snapshot index 4f5f69a1660b4..626a1f2831619 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/iife/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/iife/graph-effects.snapshot @@ -130,57 +130,59 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 3, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 1, - ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + range: Exact( + [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, }, ast_path: [ diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/graph-effects.snapshot index 8ae0097413573..cf08f621dc9cc 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/graph-effects.snapshot @@ -1,4 +1,119 @@ [ + Member { + obj: FreeVar( + "module", + ), + prop: Constant( + Str( + Atom( + "exports", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Left, + ), + AssignTarget( + Simple, + ), + SimpleAssignTarget( + Member, + ), + ], + span: 1622..1636#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "module", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Left, + ), + AssignTarget( + Simple, + ), + SimpleAssignTarget( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Ident, + ), + ], + span: 1622..1628#1, + in_try: false, + }, + FreeVar { + var: FreeVar( + "md5", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Ident, + ), + ], + span: 1639..1642#1, + in_try: false, + }, Member { obj: Variable( ( @@ -4016,6 +4131,38 @@ span: 1256..1300#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 12, + ), + ), + Stmt( + Return, + ), + ], + }, FreeVar { var: FreeVar( "safeAdd", @@ -4905,6 +5052,38 @@ span: 1459..1526#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, Call { func: Variable( ( @@ -5000,119 +5179,36 @@ span: 1577..1618#0, in_try: false, }, - Member { - obj: FreeVar( - "module", - ), - prop: Constant( - Str( - Atom( - "exports", - ), - ), - ), - ast_path: [ - Program( - Script, - ), - Script( - Body( - 3, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Left, - ), - AssignTarget( - Simple, - ), - SimpleAssignTarget( - Member, - ), - ], - span: 1622..1636#0, - in_try: false, - }, - FreeVar { - var: FreeVar( - "module", - ), - ast_path: [ + Unreachable { + start_ast_path: [ Program( Script, ), Script( Body( - 3, + 2, ), ), Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Left, - ), - AssignTarget( - Simple, - ), - SimpleAssignTarget( - Member, + Decl, ), - MemberExpr( - Obj, + Decl( + Fn, ), - Expr( - Ident, + FnDecl( + Function, ), - ], - span: 1622..1628#1, - in_try: false, - }, - FreeVar { - var: FreeVar( - "md5", - ), - ast_path: [ - Program( - Script, + Function( + Body, ), - Script( - Body( - 3, + BlockStmt( + Stmts( + 0, ), ), Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Ident, + Return, ), ], - span: 1639..1642#1, - in_try: false, }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/resolved-effects.snapshot index 80d10ff7c1f7b..05b96df21a491 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/md5-reduced/resolved-effects.snapshot @@ -1,4 +1,8 @@ -0 -> 5 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) +0 -> 2 free var = FreeVar(module) + +0 -> 3 free var = FreeVar(md5) + +0 -> 8 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -16,7 +20,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 7 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) +0 -> 10 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -34,7 +38,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 9 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, 606105819) +0 -> 12 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, 606105819) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -50,7 +54,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 11 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) +0 -> 14 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -68,7 +72,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 13 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) +0 -> 16 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -86,7 +90,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 15 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, 1200080426) +0 -> 18 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, 1200080426) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -102,7 +106,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 17 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) +0 -> 20 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -120,7 +124,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 19 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) +0 -> 22 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -138,7 +142,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 21 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1770035416) +0 -> 24 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1770035416) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -154,7 +158,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 23 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) +0 -> 26 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -172,7 +176,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 25 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) +0 -> 28 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -190,7 +194,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 27 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) +0 -> 30 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -208,7 +212,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 29 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1804603682) +0 -> 32 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1804603682) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -224,7 +228,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 31 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) +0 -> 34 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -242,7 +246,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 33 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) +0 -> 36 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -260,7 +264,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 35 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, 1236535329) +0 -> 38 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, 1236535329) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -276,15 +280,19 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 36 free var = FreeVar(safeAdd) +0 -> 39 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 40 free var = FreeVar(safeAdd) -0 -> 37 free var = FreeVar(bitRotateLeft) +0 -> 41 free var = FreeVar(bitRotateLeft) -0 -> 38 free var = FreeVar(safeAdd) +0 -> 42 free var = FreeVar(safeAdd) -0 -> 39 free var = FreeVar(safeAdd) +0 -> 43 free var = FreeVar(safeAdd) -0 -> 40 call = ???*0*(???*1*, ???*2*) +0 -> 44 call = ???*0*(???*1*, ???*2*) - *0* FreeVar(safeAdd) ⚠️ unknown global ⚠️ This value might have side effects @@ -293,9 +301,9 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 41 free var = FreeVar(safeAdd) +0 -> 45 free var = FreeVar(safeAdd) -0 -> 42 call = ???*0*(???*1*, ???*2*) +0 -> 46 call = ???*0*(???*1*, ???*2*) - *0* FreeVar(safeAdd) ⚠️ unknown global ⚠️ This value might have side effects @@ -304,7 +312,7 @@ - *2* arguments[5] ⚠️ function calls are not analysed yet -0 -> 43 call = ???*0*(???*1*, ???*3*) +0 -> 47 call = ???*0*(???*1*, ???*3*) - *0* FreeVar(safeAdd) ⚠️ unknown global ⚠️ This value might have side effects @@ -321,7 +329,7 @@ ⚠️ unknown global ⚠️ This value might have side effects -0 -> 44 call = ???*0*(???*1*, ???*3*) +0 -> 48 call = ???*0*(???*1*, ???*3*) - *0* FreeVar(bitRotateLeft) ⚠️ unknown global ⚠️ This value might have side effects @@ -334,7 +342,7 @@ - *3* arguments[4] ⚠️ function calls are not analysed yet -0 -> 45 call = ???*0*(???*1*, ???*3*) +0 -> 49 call = ???*0*(???*1*, ???*3*) - *0* FreeVar(safeAdd) ⚠️ unknown global ⚠️ This value might have side effects @@ -350,7 +358,11 @@ - *3* arguments[2] ⚠️ function calls are not analysed yet -0 -> 46 call = (...) => FreeVar(safeAdd)( +0 -> 50 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 51 call = (...) => FreeVar(safeAdd)( FreeVar(bitRotateLeft)( FreeVar(safeAdd)(FreeVar(safeAdd)(a, q), FreeVar(safeAdd)(x, t)), s @@ -370,6 +382,6 @@ - *5* arguments[6] ⚠️ function calls are not analysed yet -0 -> 48 free var = FreeVar(module) - -0 -> 49 free var = FreeVar(md5) +0 -> 52 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/md5/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/md5/resolved-effects.snapshot index 89fded395799a..f873efdd20a1a 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/md5/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/md5/resolved-effects.snapshot @@ -1,4 +1,6 @@ -0 -> 1 conditional = (???*0* == "string") +0 -> 2 free var = FreeVar(module) + +0 -> 3 conditional = (???*0* == "string") - *0* typeof((???*1* | ???*2*)) ⚠️ nested operation - *1* arguments[0] @@ -6,11 +8,11 @@ - *2* unknown new expression ⚠️ This value might have side effects -1 -> 2 free var = FreeVar(unescape) +3 -> 4 free var = FreeVar(unescape) -1 -> 3 free var = FreeVar(encodeURIComponent) +3 -> 5 free var = FreeVar(encodeURIComponent) -1 -> 4 call = ???*0*((???*1* | ???*2*)) +3 -> 6 call = ???*0*((???*1* | ???*2*)) - *0* FreeVar(encodeURIComponent) ⚠️ unknown global ⚠️ This value might have side effects @@ -19,7 +21,7 @@ - *2* unknown new expression ⚠️ This value might have side effects -1 -> 5 call = ???*0*(???*1*) +3 -> 7 call = ???*0*(???*1*) - *0* FreeVar(unescape) ⚠️ unknown global ⚠️ This value might have side effects @@ -30,9 +32,9 @@ ⚠️ unknown global ⚠️ This value might have side effects -1 -> 6 free var = FreeVar(Array) +3 -> 8 free var = FreeVar(Array) -1 -> 11 member call = ???*0*["charCodeAt"]((0 | ???*2*)) +3 -> 13 member call = ???*0*["charCodeAt"]((0 | ???*2*)) - *0* ???*1*(FreeVar(encodeURIComponent)(bytes)) ⚠️ unknown callee ⚠️ This value might have side effects @@ -42,31 +44,35 @@ - *2* updated with update expression ⚠️ This value might have side effects -0 -> 12 call = (...) => output((???*0* | ???*1*)) +0 -> 14 call = (...) => output((???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unknown new expression ⚠️ This value might have side effects -0 -> 14 call = (...) => [a, b, c, d]([], ???*0*) +0 -> 16 call = (...) => [a, b, c, d]([], ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 15 call = (...) => output(???*0*) +0 -> 17 call = (...) => output(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 18 free var = FreeVar(parseInt) +0 -> 18 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 21 free var = FreeVar(parseInt) -0 -> 20 member call = "0123456789abcdef"["charAt"](???*0*) +0 -> 23 member call = "0123456789abcdef"["charAt"](???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 22 member call = "0123456789abcdef"["charAt"](???*0*) +0 -> 25 member call = "0123456789abcdef"["charAt"](???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 23 call = ???*0*((???*1* + ???*3*), 16) +0 -> 26 call = ???*0*((???*1* + ???*3*), 16) - *0* FreeVar(parseInt) ⚠️ unknown global ⚠️ This value might have side effects @@ -79,7 +85,7 @@ - *4* unsupported expression ⚠️ This value might have side effects -0 -> 25 member call = []["push"]((???*0* | ???*1*)) +0 -> 28 member call = []["push"]((???*0* | ???*1*)) - *0* hex ⚠️ pattern without value - *1* ???*2*( @@ -96,7 +102,11 @@ - *4* unsupported expression ⚠️ This value might have side effects -0 -> 30 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) +0 -> 29 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 34 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -114,7 +124,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 32 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) +0 -> 36 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -132,7 +142,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 34 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, 606105819) +0 -> 38 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, 606105819) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -148,7 +158,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 36 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) +0 -> 40 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -166,7 +176,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 38 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) +0 -> 42 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -184,7 +194,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 40 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, 1200080426) +0 -> 44 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, 1200080426) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -200,7 +210,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 42 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) +0 -> 46 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -218,7 +228,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 44 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) +0 -> 48 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -236,7 +246,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 46 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1770035416) +0 -> 50 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1770035416) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -252,7 +262,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 48 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) +0 -> 52 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -270,7 +280,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 50 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) +0 -> 54 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -288,7 +298,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 52 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) +0 -> 56 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -306,7 +316,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 54 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1804603682) +0 -> 58 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 7, 1804603682) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -322,7 +332,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 56 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) +0 -> 60 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 12, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -340,7 +350,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 58 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) +0 -> 62 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 17, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -358,7 +368,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 60 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, 1236535329) +0 -> 64 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 22, 1236535329) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -374,7 +384,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 62 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, ???*7*) +0 -> 66 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -392,7 +402,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 64 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, ???*7*) +0 -> 68 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -410,7 +420,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 66 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, 643717713) +0 -> 70 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, 643717713) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -426,7 +436,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 68 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, ???*7*) +0 -> 72 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -444,7 +454,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 70 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, ???*7*) +0 -> 74 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -462,7 +472,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 72 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, 38016083) +0 -> 76 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, 38016083) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -478,7 +488,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 74 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, ???*7*) +0 -> 78 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -496,7 +506,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 76 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, ???*7*) +0 -> 80 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -514,7 +524,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 78 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, 568446438) +0 -> 82 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, 568446438) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -530,7 +540,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 80 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, ???*7*) +0 -> 84 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -548,7 +558,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 82 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, ???*7*) +0 -> 86 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -566,7 +576,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 84 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, 1163531501) +0 -> 88 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, 1163531501) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -582,7 +592,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 86 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, ???*7*) +0 -> 90 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 5, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -600,7 +610,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 88 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, ???*7*) +0 -> 92 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 9, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -618,7 +628,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 90 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, 1735328473) +0 -> 94 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 14, 1735328473) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -634,7 +644,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 92 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, ???*7*) +0 -> 96 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 20, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -652,7 +662,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 94 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, ???*7*) +0 -> 98 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -670,7 +680,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 96 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, ???*7*) +0 -> 100 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -688,7 +698,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 98 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, 1839030562) +0 -> 102 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, 1839030562) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -704,7 +714,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 100 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, ???*7*) +0 -> 104 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -722,7 +732,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 102 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, ???*7*) +0 -> 106 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -740,7 +750,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 104 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, 1272893353) +0 -> 108 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, 1272893353) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -756,7 +766,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 106 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, ???*7*) +0 -> 110 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -774,7 +784,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 108 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, ???*7*) +0 -> 112 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -792,7 +802,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 110 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, 681279174) +0 -> 114 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, 681279174) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -808,7 +818,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 112 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, ???*7*) +0 -> 116 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -826,7 +836,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 114 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, ???*7*) +0 -> 118 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -844,7 +854,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 116 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, 76029189) +0 -> 120 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, 76029189) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -860,7 +870,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 118 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, ???*7*) +0 -> 122 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 4, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -878,7 +888,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 120 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, ???*7*) +0 -> 124 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 11, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -896,7 +906,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 122 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, 530742520) +0 -> 126 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 16, 530742520) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -912,7 +922,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 124 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, ???*7*) +0 -> 128 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 23, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -930,7 +940,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 126 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, ???*7*) +0 -> 130 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -948,7 +958,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 128 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, 1126891415) +0 -> 132 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, 1126891415) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -964,7 +974,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 130 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, ???*7*) +0 -> 134 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -982,7 +992,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 132 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, ???*7*) +0 -> 136 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1000,7 +1010,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 134 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, 1700485571) +0 -> 138 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, 1700485571) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1016,7 +1026,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 136 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, ???*7*) +0 -> 140 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1034,7 +1044,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 138 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, ???*7*) +0 -> 142 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1052,7 +1062,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 140 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, ???*7*) +0 -> 144 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1070,7 +1080,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 142 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, 1873313359) +0 -> 146 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, 1873313359) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1086,7 +1096,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 144 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, ???*7*) +0 -> 148 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1104,7 +1114,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 146 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, ???*7*) +0 -> 150 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1122,7 +1132,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 148 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, 1309151649) +0 -> 152 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, 1309151649) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1138,7 +1148,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 150 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, ???*7*) +0 -> 154 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 6, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1156,7 +1166,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 152 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, ???*7*) +0 -> 156 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 10, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1174,7 +1184,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 154 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, 718787259) +0 -> 158 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 15, 718787259) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1190,7 +1200,7 @@ - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 156 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, ???*7*) +0 -> 160 call = (...) => md5cmn(???*0*, a, b, x, s, t)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, 21, ???*7*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1208,7 +1218,7 @@ - *7* unsupported expression ⚠️ This value might have side effects -0 -> 157 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 161 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1216,7 +1226,7 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 158 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 162 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1224,7 +1234,7 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 159 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 163 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1232,7 +1242,7 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 160 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 164 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1240,9 +1250,25 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 163 free var = FreeVar(undefined) +0 -> 165 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 168 free var = FreeVar(undefined) + +0 -> 174 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 175 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 176 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 169 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 177 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -1250,7 +1276,7 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 170 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 178 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[3] @@ -1258,7 +1284,7 @@ - *2* arguments[5] ⚠️ function calls are not analysed yet -0 -> 171 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 179 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -1266,7 +1292,7 @@ - *2* unsupported expression ⚠️ This value might have side effects -0 -> 172 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 180 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -1274,7 +1300,7 @@ - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 173 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 181 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -1282,7 +1308,11 @@ - *2* arguments[2] ⚠️ function calls are not analysed yet -0 -> 174 call = (...) => safeAdd( +0 -> 182 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 183 call = (...) => safeAdd( bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b )(???*0*, ???*1*, ???*2*, ???*3*, ???*4*, ???*5*) @@ -1299,7 +1329,11 @@ - *5* arguments[6] ⚠️ function calls are not analysed yet -0 -> 175 call = (...) => safeAdd( +0 -> 184 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 185 call = (...) => safeAdd( bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b )(???*0*, ???*1*, ???*2*, ???*3*, ???*4*, ???*5*) @@ -1316,7 +1350,11 @@ - *5* arguments[6] ⚠️ function calls are not analysed yet -0 -> 176 call = (...) => safeAdd( +0 -> 186 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 187 call = (...) => safeAdd( bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b )(???*0*, ???*1*, ???*2*, ???*3*, ???*4*, ???*5*) @@ -1333,7 +1371,11 @@ - *5* arguments[6] ⚠️ function calls are not analysed yet -0 -> 177 call = (...) => safeAdd( +0 -> 188 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 189 call = (...) => safeAdd( bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b )(???*0*, ???*1*, ???*2*, ???*3*, ???*4*, ???*5*) @@ -1350,4 +1392,6 @@ - *5* arguments[6] ⚠️ function calls are not analysed yet -0 -> 179 free var = FreeVar(module) +0 -> 190 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/graph-effects.snapshot index 5c726ba52876b..78ea1d9352d39 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/graph-effects.snapshot @@ -1472,91 +1472,93 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -1814,91 +1816,93 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - ], + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -1990,85 +1994,87 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -2906,91 +2912,93 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -3648,115 +3656,117 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], - }, - }, - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, - ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), + }, + }, + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( Call, ), CallExpr( @@ -3836,91 +3846,93 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - ], + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -4012,85 +4024,87 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 0, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 4, + Stmt( + Expr, ), - ), - VarDeclarator( - Init, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + ExprStmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - ], + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -27673,21 +27687,8 @@ span: 4940..4966#0, in_try: false, }, - Member { - obj: Variable( - ( - "md5", - #3, - ), - ), - prop: Constant( - Str( - Atom( - "_ff", - ), - ), - ), - ast_path: [ + Unreachable { + start_ast_path: [ Program( Script, ), @@ -27728,30 +27729,41 @@ ), BlockStmt( Stmts( - 1, + 0, ), ), Stmt( - Expr, + Decl, ), - ExprStmt( - Expr, + Decl( + Var, + ), + VarDecl( + Decls( + 4, + ), + ), + VarDeclarator( + Init, ), Expr( - Assign, + Fn, ), - AssignExpr( - Left, + FnExpr( + Function, ), - AssignTarget( - Simple, + Function( + Body, ), - SimpleAssignTarget( - Member, + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Return, ), ], - span: 5003..5010#0, - in_try: false, }, Member { obj: Variable( @@ -27763,7 +27775,7 @@ prop: Constant( Str( Atom( - "_gg", + "_ff", ), ), ), @@ -27808,7 +27820,7 @@ ), BlockStmt( Stmts( - 2, + 1, ), ), Stmt( @@ -27830,24 +27842,11 @@ Member, ), ], - span: 5153..5160#0, + span: 5003..5010#0, in_try: false, }, - Member { - obj: Variable( - ( - "md5", - #3, - ), - ), - prop: Constant( - Str( - Atom( - "_hh", - ), - ), - ), - ast_path: [ + Unreachable { + start_ast_path: [ Program( Script, ), @@ -27888,7 +27887,7 @@ ), BlockStmt( Stmts( - 3, + 1, ), ), Stmt( @@ -27901,17 +27900,26 @@ Assign, ), AssignExpr( - Left, + Right, ), - AssignTarget( - Simple, + Expr( + Fn, ), - SimpleAssignTarget( - Member, + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, ), ], - span: 5303..5310#0, - in_try: false, }, Member { obj: Variable( @@ -27923,7 +27931,7 @@ prop: Constant( Str( Atom( - "_ii", + "_gg", ), ), ), @@ -27968,7 +27976,7 @@ ), BlockStmt( Stmts( - 4, + 2, ), ), Stmt( @@ -27990,13 +27998,401 @@ Member, ), ], - span: 5444..5451#0, + span: 5153..5160#0, in_try: false, }, - Member { - obj: Variable( - ( - "md5", + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Member { + obj: Variable( + ( + "md5", + #3, + ), + ), + prop: Constant( + Str( + Atom( + "_hh", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Left, + ), + AssignTarget( + Simple, + ), + SimpleAssignTarget( + Member, + ), + ], + span: 5303..5310#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 3, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Member { + obj: Variable( + ( + "md5", + #3, + ), + ), + prop: Constant( + Str( + Atom( + "_ii", + ), + ), + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 4, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Left, + ), + AssignTarget( + Simple, + ), + SimpleAssignTarget( + Member, + ), + ], + span: 5444..5451#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 4, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Member { + obj: Variable( + ( + "md5", #3, ), ), @@ -28541,83 +28937,85 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 7, + Script( + Body( + 0, + ), ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Stmt( + Expr, ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, }, ast_path: [ @@ -29214,89 +29612,91 @@ kind: Ternary { then: EffectsBlock { effects: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 7, + Script( + Body( + 0, + ), ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 2, + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -29685,95 +30085,97 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 7, + Script( + Body( + 0, + ), ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 2, + Stmt( + Expr, ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -30015,95 +30417,97 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 7, + Script( + Body( + 0, + ), ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 2, + Stmt( + Expr, ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -30199,89 +30603,91 @@ in_try: false, }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Paren, - ), - ParenExpr( - Expr, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 7, + Script( + Body( + 0, + ), ), - ), - Stmt( - Expr, - ), - ExprStmt( - Expr, - ), - Expr( - Assign, - ), - AssignExpr( - Right, - ), - Expr( - Fn, - ), - FnExpr( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 2, + Stmt( + Expr, ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -30370,4 +30776,80 @@ span: 5897..6056#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Paren, + ), + ParenExpr( + Expr, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 7, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Assign, + ), + AssignExpr( + Right, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/resolved-effects.snapshot index 741d5b1621a31..c2a1ba429f664 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/md5_2/resolved-effects.snapshot @@ -3099,11 +3099,31 @@ - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 186 free var = FreeVar(module) +0 -> 179 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 181 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 183 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 185 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 187 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 187 free var = FreeVar(undefined) +0 -> 191 free var = FreeVar(module) -0 -> 188 conditional = ((???*0* === ???*1*) | (???*2* === null)) +0 -> 192 free var = FreeVar(undefined) + +0 -> 193 conditional = ((???*0* === ???*1*) | (???*2* === null)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* FreeVar(undefined) @@ -3112,19 +3132,19 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -188 -> 189 free var = FreeVar(Error) +193 -> 194 free var = FreeVar(Error) -0 -> 191 call = (...) => crypt["endian"]([a, b, c, d])(???*0*, ???*1*) +0 -> 196 call = (...) => crypt["endian"]([a, b, c, d])(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 192 member call = module["wordsToBytes"](???*0*) +0 -> 197 member call = module["wordsToBytes"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 194 conditional = (???*0* | ???*1*) +0 -> 199 conditional = (???*0* | ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["asBytes"] @@ -3132,7 +3152,7 @@ - *2* arguments[1] ⚠️ function calls are not analysed yet -194 -> 196 conditional = (???*0* | ???*1*) +199 -> 201 conditional = (???*0* | ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["asString"] @@ -3140,10 +3160,14 @@ - *2* arguments[1] ⚠️ function calls are not analysed yet -196 -> 198 member call = module["bin"]["bytesToString"](???*0*) +201 -> 203 member call = module["bin"]["bytesToString"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -196 -> 200 member call = module["bytesToHex"](???*0*) +201 -> 205 member call = module["bytesToHex"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects + +0 -> 206 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/graph-effects.snapshot index c4ed549499ebd..a5998a1fbf3a2 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/graph-effects.snapshot @@ -1,4 +1,136 @@ [ + Call { + func: Variable( + ( + "outer", + #2, + ), + ), + args: [ + Value( + Constant( + Str( + Word( + "a", + ), + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Call, + ), + ], + span: 295..305#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Fn, + ), + FnExpr( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, Call { func: Variable( ( @@ -135,40 +267,89 @@ ), kind: IfElse { then: EffectsBlock { - effects: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 2, + effects: [ + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, + ], + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 2, + ), ), - ), - Stmt( - If, - ), - IfStmt( - Cons, - ), - ], + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -260,40 +441,88 @@ span: 159..167#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 2, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Script( + Body( + 2, + ), ), - ), - Stmt( - If, - ), - IfStmt( - Alt, - ), - ], + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + IfStmt( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -332,6 +561,38 @@ span: 105..176#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + If, + ), + ], + }, Call { func: Variable( ( @@ -437,52 +698,85 @@ span: 271..281#0, in_try: false, }, - Call { - func: Variable( - ( - "outer", - #2, + Unreachable { + start_ast_path: [ + Program( + Script, ), - ), - args: [ - Value( - Constant( - Str( - Word( - "a", - ), - ), + Script( + Body( + 4, ), ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), ], - ast_path: [ + }, + Unreachable { + start_ast_path: [ Program( Script, ), Script( Body( - 5, + 4, ), ), Stmt( Decl, ), Decl( - Var, + Fn, ), - VarDecl( - Decls( + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( 0, ), ), - VarDeclarator( - Init, + Stmt( + Decl, ), - Expr( - Call, + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, ), ], - span: 295..305#0, - in_try: false, }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/resolved-effects.snapshot index 130958ca5ae1f..e5696dae0ee74 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/nested-args/resolved-effects.snapshot @@ -1,17 +1,45 @@ -0 -> 1 call = (...) => y(1) +0 -> 1 call = (...) => inner("b")("a") -0 -> 2 call = (...) => (a + b)(2) +0 -> 2 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4 call = (...) => y(1) -0 -> 3 conditional = (???*0* === 0) +0 -> 5 call = (...) => (a + b)(2) + +0 -> 6 conditional = (???*0* === 0) - *0* unsupported expression ⚠️ This value might have side effects -3 -> 4 call = (...) => (undefined | a | (r((a + 1)) + 1))((???*0* + 1)) +6 -> 7 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +6 -> 8 call = (...) => (undefined | a | (r((a + 1)) + 1))((???*0* + 1)) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 5 call = (...) => (undefined | a | (r((a + 1)) + 1))(2) +6 -> 9 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 10 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 11 call = (...) => (undefined | a | (r((a + 1)) + 1))(2) -0 -> 6 call = (...) => (a + b)("b") +0 -> 12 call = (...) => (a + b)("b") -0 -> 7 call = (...) => inner("b")("a") +0 -> 13 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 14 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-effects.snapshot index 11d6bb8686f76..2038f6099abe0 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/graph-effects.snapshot @@ -688,6 +688,92 @@ span: 257..301#0, in_try: true, }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Object, + ), + ObjectLit( + Props( + 0, + ), + ), + PropOrSpread( + Prop, + ), + Prop( + KeyValue, + ), + KeyValueProp( + Value, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, Member { obj: FreeVar( "performance", @@ -1054,6 +1140,44 @@ span: 356..373#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 1, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, Conditional { condition: Binary( 3, @@ -1139,115 +1263,119 @@ in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 2, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - ModuleDecl, - ), - ModuleDecl( - ExportDecl, - ), - ExportDecl( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Module( + Body( + 2, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + ModuleItem( + ModuleDecl, ), - ), - VarDeclarator( - Init, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 2, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - ModuleDecl, - ), - ModuleDecl( - ExportDecl, - ), - ExportDecl( - Decl, - ), - Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, - ), - BlockStmt( - Stmts( - 0, + Module( + Body( + 2, + ), ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + ModuleItem( + ModuleDecl, ), - ), - VarDeclarator( - Init, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -1365,4 +1493,42 @@ span: 608..621#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Module, + ), + Module( + Body( + 2, + ), + ), + ModuleItem( + ModuleDecl, + ), + ModuleDecl( + ExportDecl, + ), + ExportDecl( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 2, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-effects.snapshot index 9f17676ad99df..14b9791e26090 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/op-assign/resolved-effects.snapshot @@ -13,14 +13,22 @@ - *2* spread ⚠️ This value might have side effects -0 -> 8 free var = FreeVar(performance) +0 -> 7 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 9 free var = FreeVar(performance) -0 -> 9 member call = ???*0*["now"]() +0 -> 10 member call = ???*0*["now"]() - *0* FreeVar(performance) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 10 conditional = ((0 | ???*0*) === 0) +0 -> 11 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 12 conditional = ((0 | ???*0*) === 0) - *0* (???*1* + ???*2*) ⚠️ nested operation - *1* clientComponentLoadTimes @@ -28,4 +36,8 @@ - *2* unsupported expression ⚠️ This value might have side effects -10 -> 11 free var = FreeVar(undefined) +12 -> 13 free var = FreeVar(undefined) + +0 -> 15 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2236/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2236/graph-effects.snapshot index 6470003e71890..0196a5d67c7ff 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2236/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2236/graph-effects.snapshot @@ -182,39 +182,41 @@ in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 2, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Module( + Body( + 2, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [ @@ -263,39 +265,41 @@ in_try: false, }, ], - ast_path: [ - Program( - Module, - ), - Module( - Body( - 2, + range: Exact( + [ + Program( + Module, ), - ), - ModuleItem( - Stmt, - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Module( + Body( + 2, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + ModuleItem( + Stmt, + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot index aab7e41e1f201..6ffff8e675c12 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/graph-effects.snapshot @@ -378,165 +378,169 @@ kind: Ternary { then: EffectsBlock { effects: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Script( + Body( + 0, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 1, + Stmt( + Decl, ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + Decl( + Var, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Object, - ), - ObjectLit( - Props( - 1, + VarDecl( + Decls( + 0, + ), ), - ), - PropOrSpread( - Prop, - ), - Prop( - KeyValue, - ), - KeyValueProp( - Value, - ), - Expr( - Cond, - ), - CondExpr( - Cons, - ), - ], + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Object, + ), + ObjectLit( + Props( + 1, + ), + ), + PropOrSpread( + Prop, + ), + Prop( + KeyValue, + ), + KeyValueProp( + Value, + ), + Expr( + Cond, + ), + CondExpr( + Cons, + ), + ], + ), }, else: EffectsBlock { effects: [], - ast_path: [ - Program( - Script, - ), - Script( - Body( - 0, + range: Exact( + [ + Program( + Script, ), - ), - Stmt( - Decl, - ), - Decl( - Var, - ), - VarDecl( - Decls( - 0, + Script( + Body( + 0, + ), ), - ), - VarDeclarator( - Init, - ), - Expr( - Arrow, - ), - ArrowExpr( - Body, - ), - BlockStmtOrExpr( - BlockStmt, - ), - BlockStmt( - Stmts( - 1, + Stmt( + Decl, ), - ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Args( - 0, + Decl( + Var, ), - ), - ExprOrSpread( - Expr, - ), - Expr( - Object, - ), - ObjectLit( - Props( - 1, + VarDecl( + Decls( + 0, + ), ), - ), - PropOrSpread( - Prop, - ), - Prop( - KeyValue, - ), - KeyValueProp( - Value, - ), - Expr( - Cond, - ), - CondExpr( - Alt, - ), - ], + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ReturnStmt( + Arg, + ), + Expr( + Call, + ), + CallExpr( + Args( + 0, + ), + ), + ExprOrSpread( + Expr, + ), + Expr( + Object, + ), + ObjectLit( + Props( + 1, + ), + ), + PropOrSpread( + Prop, + ), + Prop( + KeyValue, + ), + KeyValueProp( + Value, + ), + Expr( + Cond, + ), + CondExpr( + Alt, + ), + ], + ), }, }, ast_path: [ @@ -760,6 +764,49 @@ span: 273..398#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, Call { func: Variable( ( diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot index 5e45590c28702..c178e8c5f7984 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/pack-2682/resolved-effects.snapshot @@ -33,7 +33,11 @@ - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 8 call = (...) => FreeVar(JSON)["stringify"]( +0 -> 8 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 9 call = (...) => FreeVar(JSON)["stringify"]( { "condition": (variable === "true"), "buggedConditionalCheck": ((variable === "true") ? "true" : "false") diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot index 1660891e6abdf..a2d45a80a9822 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/peg/resolved-effects.snapshot @@ -1,6 +1,8 @@ -0 -> 11 free var = FreeVar(Error) +0 -> 2 free var = FreeVar(module) -0 -> 12 conditional = (???*0* === "function") +0 -> 13 free var = FreeVar(Error) + +0 -> 14 conditional = (???*0* === "function") - *0* typeof(???*1*) ⚠️ nested operation - *1* ???*2*["captureStackTrace"] @@ -10,31 +12,56 @@ ⚠️ unknown global ⚠️ This value might have side effects -12 -> 14 free var = FreeVar(Error) +14 -> 16 free var = FreeVar(Error) -12 -> 15 member call = ???*0*["captureStackTrace"](???*1*, (...) => undefined) +14 -> 17 member call = ???*0*["captureStackTrace"](???*1*, (...) => undefined) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -0 -> 16 free var = FreeVar(Error) +0 -> 18 free var = FreeVar(Error) -0 -> 17 call = (...) => undefined((...) => undefined, ???*0*) +0 -> 19 call = (...) => undefined((...) => undefined, ???*0*) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 20 call = (...) => s["replace"](/\\/g, "\\\\")["replace"](/"/g, "\\\"")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 1822*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 1920*)(???*0*) +0 -> 21 call = (...) => ( + | undefined + | descriptions[0] + | `${descriptions[0]} or ${descriptions[1]}` + | `${descriptions["slice"](0, ???*0*)["join"](", ")}, or ${descriptions[???*1*]}` +)(???*2*) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 22 call = (...) => (found ? `"${literalEscape(found)}"` : "end of input")(???*0*) +- *0* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 23 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 25 call = (...) => s["replace"](/\\/g, "\\\\")["replace"](/"/g, "\\\"")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 1822*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 1920*)(???*0*) - *0* ???*1*["text"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 25 free var = FreeVar(Array) +0 -> 26 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 31 free var = FreeVar(Array) -0 -> 29 call = (...) => ...[...](..., ...)["replace"](/\^/g, "\\^")["replace"](/-/g, "\\-")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 2287*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 2385*)(???*0*) +0 -> 35 call = (...) => ...[...](..., ...)["replace"](/\^/g, "\\^")["replace"](/-/g, "\\-")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 2287*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 2385*)(???*0*) - *0* ???*1*[0] ⚠️ unknown object - *1* ???*2*[i] @@ -44,7 +71,7 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 33 call = (...) => ...[...](..., ...)["replace"](/\^/g, "\\^")["replace"](/-/g, "\\-")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 2287*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 2385*)(???*0*) +0 -> 39 call = (...) => ...[...](..., ...)["replace"](/\^/g, "\\^")["replace"](/-/g, "\\-")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 2287*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 2385*)(???*0*) - *0* ???*1*[1] ⚠️ unknown object - *1* ???*2*[i] @@ -54,7 +81,7 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 36 call = (...) => ...[...](..., ...)["replace"](/\^/g, "\\^")["replace"](/-/g, "\\-")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 2287*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 2385*)(???*0*) +0 -> 42 call = (...) => ...[...](..., ...)["replace"](/\^/g, "\\^")["replace"](/-/g, "\\-")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 2287*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 2385*)(???*0*) - *0* ???*1*[i] ⚠️ unknown object - *1* ???*2*["parts"] @@ -62,23 +89,39 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 38 conditional = ???*0* +0 -> 44 conditional = ???*0* - *0* ???*1*["inverted"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 43 member call = ???*0*["charCodeAt"](0) +0 -> 45 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 46 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 47 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 49 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 53 member call = ???*0*["charCodeAt"](0) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 44 member call = ???*0*["toString"](16) +0 -> 54 member call = ???*0*["toString"](16) - *0* ???*1*["charCodeAt"](0) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 45 member call = ???*0*["toUpperCase"]() +0 -> 55 member call = ???*0*["toUpperCase"]() - *0* ???*1*["toString"](16) ⚠️ unknown callee object - *1* ???*2*["charCodeAt"](0) @@ -86,17 +129,21 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 54 member call = ???*0*["replace"](/\\/g, "\\\\") +0 -> 56 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 65 member call = ???*0*["replace"](/\\/g, "\\\\") - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 55 member call = ???*0*["replace"](/"/g, "\\\"") +0 -> 66 member call = ???*0*["replace"](/"/g, "\\\"") - *0* ???*1*["replace"](/\\/g, "\\\\") ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 56 member call = ???*0*["replace"](/\0/g, "\\0") +0 -> 67 member call = ???*0*["replace"](/\0/g, "\\0") - *0* ???*1*["replace"](/"/g, "\\\"") ⚠️ unknown callee object - *1* ???*2*["replace"](/\\/g, "\\\\") @@ -104,7 +151,7 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 57 member call = ???*0*["replace"](/\t/g, "\\t") +0 -> 68 member call = ???*0*["replace"](/\t/g, "\\t") - *0* ???*1*["replace"](/\0/g, "\\0") ⚠️ unknown callee object - *1* ???*2*["replace"](/"/g, "\\\"") @@ -114,7 +161,7 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 58 member call = ???*0*["replace"](/\n/g, "\\n") +0 -> 69 member call = ???*0*["replace"](/\n/g, "\\n") - *0* ???*1*["replace"](/\t/g, "\\t") ⚠️ unknown callee object - *1* ???*2*["replace"](/\0/g, "\\0") @@ -126,7 +173,7 @@ - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 59 member call = ???*0*["replace"](/\r/g, "\\r") +0 -> 70 member call = ???*0*["replace"](/\r/g, "\\r") - *0* ???*1*["replace"](/\n/g, "\\n") ⚠️ unknown callee object - *1* ???*2*["replace"](/\t/g, "\\t") @@ -138,7 +185,7 @@ - *4* ???["replace"](/\\/g, "\\\\") ⚠️ unknown callee object -0 -> 60 member call = ???*0*["replace"](/[\x00-\x0F]/g, (...) => `\x0${hex(ch)}`) +0 -> 71 member call = ???*0*["replace"](/[\x00-\x0F]/g, (...) => `\x0${hex(ch)}`) - *0* ???*1*["replace"](/\r/g, "\\r") ⚠️ unknown callee object - *1* ???*2*["replace"](/\n/g, "\\n") @@ -150,11 +197,15 @@ - *4* ???["replace"](/"/g, "\\\"") ⚠️ unknown callee object -60 -> 61 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) +71 -> 72 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 62 member call = ???*0*["replace"](/[\x10-\x1F\x7F-\x9F]/g, (...) => `\x${hex(ch)}`) +71 -> 73 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 74 member call = ???*0*["replace"](/[\x10-\x1F\x7F-\x9F]/g, (...) => `\x${hex(ch)}`) - *0* ???*1*["replace"](/[\x00-\x0F]/g, *anonymous function 1822*) ⚠️ unknown callee object - *1* ???*2*["replace"](/\r/g, "\\r") @@ -166,21 +217,29 @@ - *4* ???["replace"](/\0/g, "\\0") ⚠️ unknown callee object -62 -> 63 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) +74 -> 75 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 74 member call = ???*0*["replace"](/\\/g, "\\\\") +74 -> 76 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 77 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 88 member call = ???*0*["replace"](/\\/g, "\\\\") - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 75 member call = ???*0*["replace"](/\]/g, "\\]") +0 -> 89 member call = ???*0*["replace"](/\]/g, "\\]") - *0* ???*1*["replace"](/\\/g, "\\\\") ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 76 member call = ???*0*["replace"](/\^/g, "\\^") +0 -> 90 member call = ???*0*["replace"](/\^/g, "\\^") - *0* ???*1*["replace"](/\]/g, "\\]") ⚠️ unknown callee object - *1* ???*2*["replace"](/\\/g, "\\\\") @@ -188,7 +247,7 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 77 member call = ???*0*["replace"](/-/g, "\\-") +0 -> 91 member call = ???*0*["replace"](/-/g, "\\-") - *0* ???*1*["replace"](/\^/g, "\\^") ⚠️ unknown callee object - *1* ???*2*["replace"](/\]/g, "\\]") @@ -198,7 +257,7 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 78 member call = ???*0*["replace"](/\0/g, "\\0") +0 -> 92 member call = ???*0*["replace"](/\0/g, "\\0") - *0* ???*1*["replace"](/-/g, "\\-") ⚠️ unknown callee object - *1* ???*2*["replace"](/\^/g, "\\^") @@ -210,7 +269,7 @@ - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 79 member call = ???*0*["replace"](/\t/g, "\\t") +0 -> 93 member call = ???*0*["replace"](/\t/g, "\\t") - *0* ???*1*["replace"](/\0/g, "\\0") ⚠️ unknown callee object - *1* ???*2*["replace"](/-/g, "\\-") @@ -222,7 +281,7 @@ - *4* ???["replace"](/\\/g, "\\\\") ⚠️ unknown callee object -0 -> 80 member call = ???*0*["replace"](/\n/g, "\\n") +0 -> 94 member call = ???*0*["replace"](/\n/g, "\\n") - *0* ???*1*["replace"](/\t/g, "\\t") ⚠️ unknown callee object - *1* ???*2*["replace"](/\0/g, "\\0") @@ -234,7 +293,7 @@ - *4* ???["replace"](/\]/g, "\\]") ⚠️ unknown callee object -0 -> 81 member call = ???*0*["replace"](/\r/g, "\\r") +0 -> 95 member call = ???*0*["replace"](/\r/g, "\\r") - *0* ???*1*["replace"](/\n/g, "\\n") ⚠️ unknown callee object - *1* ???*2*["replace"](/\t/g, "\\t") @@ -246,7 +305,7 @@ - *4* ???["replace"](/\^/g, "\\^") ⚠️ unknown callee object -0 -> 82 member call = ???*0*["replace"](/[\x00-\x0F]/g, (...) => `\x0${hex(ch)}`) +0 -> 96 member call = ???*0*["replace"](/[\x00-\x0F]/g, (...) => `\x0${hex(ch)}`) - *0* ???*1*["replace"](/\r/g, "\\r") ⚠️ unknown callee object - *1* ???*2*["replace"](/\n/g, "\\n") @@ -258,11 +317,15 @@ - *4* ???["replace"](/-/g, "\\-") ⚠️ unknown callee object -82 -> 83 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) +96 -> 97 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 84 member call = ???*0*["replace"](/[\x10-\x1F\x7F-\x9F]/g, (...) => `\x${hex(ch)}`) +96 -> 98 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 99 member call = ???*0*["replace"](/[\x10-\x1F\x7F-\x9F]/g, (...) => `\x${hex(ch)}`) - *0* ???*1*["replace"](/[\x00-\x0F]/g, *anonymous function 2287*) ⚠️ unknown callee object - *1* ???*2*["replace"](/\r/g, "\\r") @@ -274,11 +337,19 @@ - *4* ???["replace"](/\0/g, "\\0") ⚠️ unknown callee object -84 -> 85 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) +99 -> 100 call = (...) => ch["charCodeAt"](0)["toString"](16)["toUpperCase"]()(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 88 member call = { +99 -> 101 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 102 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 105 member call = { "literal": (...) => `"${literalEscape(expectation["text"])}"`, "class": (...) => `[${(expectation["inverted"] ? "^" : "")}${escapedParts}]`, "any": (...) => "any character", @@ -292,19 +363,23 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 89 free var = FreeVar(Array) +0 -> 106 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 107 free var = FreeVar(Array) -0 -> 94 call = (...) => DESCRIBE_EXPECTATION_FNS[expectation["type"]](expectation)(???*0*) +0 -> 112 call = (...) => DESCRIBE_EXPECTATION_FNS[expectation["type"]](expectation)(???*0*) - *0* ???*1*[i] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 96 member call = ???*0*["sort"]() +0 -> 114 member call = ???*0*["sort"]() - *0* unknown new expression ⚠️ This value might have side effects -0 -> 101 conditional = (???*0* !== ???*3*) +0 -> 119 conditional = (???*0* !== ???*3*) - *0* ???*1*[???*2*] ⚠️ unknown object ⚠️ This value might have side effects @@ -318,13 +393,21 @@ - *4* unknown new expression ⚠️ This value might have side effects -0 -> 111 member call = ???*0*["slice"](0, ???*1*) +0 -> 125 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 128 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 131 member call = ???*0*["slice"](0, ???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -0 -> 112 member call = ???*0*["join"](", ") +0 -> 132 member call = ???*0*["join"](", ") - *0* ???*1*["slice"](0, ???*2*) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -333,32 +416,84 @@ - *2* unsupported expression ⚠️ This value might have side effects -0 -> 115 conditional = ???*0* +0 -> 135 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 136 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analysed yet -115 -> 116 call = (...) => s["replace"](/\\/g, "\\\\")["replace"](/"/g, "\\\"")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 1822*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 1920*)(???*0*) +136 -> 137 call = (...) => s["replace"](/\\/g, "\\\\")["replace"](/"/g, "\\\"")["replace"](/\0/g, "\\0")["replace"](/\t/g, "\\t")["replace"](/\n/g, "\\n")["replace"](/\r/g, "\\r")["replace"](/[\x00-\x0F]/g, *anonymous function 1822*)["replace"](/[\x10-\x1F\x7F-\x9F]/g, *anonymous function 1920*)(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 117 call = (...) => ( - | undefined - | descriptions[0] - | `${descriptions[0]} or ${descriptions[1]}` - | `${descriptions["slice"](0, ???*0*)["join"](", ")}, or ${descriptions[???*1*]}` -)(???*2*) -- *0* unsupported expression +0 -> 138 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* unsupported expression + +0 -> 139 call = ((...) => s0 | ???*0*)() +- *0* {}[???*1*] + ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects -- *2* arguments[0] +- *1* ???*2*["startRule"] + ⚠️ unknown object +- *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 118 call = (...) => (found ? `"${literalEscape(found)}"` : "end of input")(???*0*) -- *0* arguments[1] +0 -> 141 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +141 -> 143 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +143 -> 144 call = (...) => {"type": "end"}() + +143 -> 145 call = (...) => (undefined | FreeVar(undefined))({"type": "end"}) + +141 -> 148 member call = ???*0*["charAt"](???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +141 -> 150 call = (...) => { + "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, + "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} +}(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +141 -> 151 call = (...) => { + "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, + "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} +}(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +141 -> 152 call = (...) => ???*0*([], (???*1* ? ???*2* : null), ???*4*) +- *0* unknown new expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* ???*3*["charAt"](peg$maxFailPos) + ⚠️ unknown callee object +- *3* arguments[0] ⚠️ function calls are not analysed yet +- *4* max number of linking steps reached + ⚠️ This value might have side effects + +141 -> 153 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 119 conditional = ((???*0* | ???*1*) !== ???*6*) +0 -> 154 conditional = ((???*0* | ???*1*) !== ???*6*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* (???*2* ? ???*5* : {}) @@ -374,45 +509,153 @@ - *6* unsupported expression ⚠️ This value might have side effects -0 -> 120 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("*", false) +0 -> 155 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 156 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 157 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 158 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 121 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(",", false) +0 -> 159 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 160 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 122 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(".", false) +0 -> 161 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("*", false) -0 -> 123 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("(", false) +0 -> 162 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 124 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(")", false) +0 -> 163 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 164 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 125 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("{", false) +0 -> 165 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(",", false) -0 -> 126 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("}", false) +0 -> 166 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 167 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 168 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 169 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 170 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 171 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 172 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 127 conditional = ???*0* +0 -> 173 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 174 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 175 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 176 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(".", false) + +0 -> 177 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("(", false) + +0 -> 178 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(")", false) + +0 -> 179 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 180 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 181 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("{", false) + +0 -> 182 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("}", false) + +0 -> 183 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 128 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("[", false) +0 -> 184 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 129 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("]", false) +0 -> 185 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("[", false) -0 -> 130 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("undefined", false) +0 -> 186 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("]", false) -0 -> 131 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("-", false) +0 -> 187 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 188 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("undefined", false) + +0 -> 189 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 190 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 191 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 192 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 132 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("0x", false) +0 -> 193 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("-", false) -0 -> 133 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["0", "9"]], false, false) +0 -> 194 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("0x", false) -0 -> 134 conditional = ???*0* +0 -> 195 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["0", "9"]], false, false) + +0 -> 196 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analysed yet -134 -> 135 free var = FreeVar(parseInt) +196 -> 197 free var = FreeVar(parseInt) -134 -> 136 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +196 -> 198 call = (...) => input["substring"](peg$savedPos, peg$currPos)() -134 -> 137 call = ???*0*(???*1*, 16) +196 -> 199 call = ???*0*(???*1*, 16) - *0* FreeVar(parseInt) ⚠️ unknown global ⚠️ This value might have side effects @@ -421,11 +664,11 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -134 -> 138 free var = FreeVar(parseFloat) +196 -> 200 free var = FreeVar(parseFloat) -134 -> 139 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +196 -> 201 call = (...) => input["substring"](peg$savedPos, peg$currPos)() -134 -> 140 call = ???*0*(???*1*) +196 -> 202 call = ???*0*(???*1*) - *0* FreeVar(parseFloat) ⚠️ unknown global ⚠️ This value might have side effects @@ -434,112 +677,192 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 141 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("\"", false) +0 -> 203 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 204 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("\"", false) -0 -> 143 member call = ???*0*["join"]("") +0 -> 206 member call = ???*0*["join"]("") - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 144 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("'", false) +0 -> 207 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 208 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("'", false) + +0 -> 209 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 210 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 211 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([" ", "\t", "\n", "\r"], false, false) + +0 -> 212 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("--", false) + +0 -> 213 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}(["\n", "\r"], false, false) + +0 -> 214 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("SELECT", true) -0 -> 145 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([" ", "\t", "\n", "\r"], false, false) +0 -> 215 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("TOP", true) -0 -> 146 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("--", false) +0 -> 216 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("FROM", true) -0 -> 147 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}(["\n", "\r"], false, false) +0 -> 217 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("WHERE", true) -0 -> 148 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("SELECT", true) +0 -> 218 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("ORDER", true) -0 -> 149 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("TOP", true) +0 -> 219 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("BY", true) -0 -> 150 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("FROM", true) +0 -> 220 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("AS", true) -0 -> 151 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("WHERE", true) +0 -> 221 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("JOIN", true) -0 -> 152 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("ORDER", true) +0 -> 222 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("IN", true) -0 -> 153 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("BY", true) +0 -> 223 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("VALUE", true) -0 -> 154 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("AS", true) +0 -> 224 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("ASC", true) -0 -> 155 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("JOIN", true) +0 -> 225 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 156 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("IN", true) +0 -> 226 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("DESC", true) -0 -> 157 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("VALUE", true) +0 -> 227 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 158 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("ASC", true) +0 -> 228 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("AND", true) -0 -> 159 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("DESC", true) +0 -> 229 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 160 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("AND", true) +0 -> 230 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("OR", true) -0 -> 161 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("OR", true) +0 -> 231 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 162 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("NOT", true) +0 -> 232 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("NOT", true) -0 -> 163 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("BETWEEN", true) +0 -> 233 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 234 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("BETWEEN", true) -0 -> 164 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("EXISTS", true) +0 -> 235 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("EXISTS", true) -0 -> 165 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("ARRAY", true) +0 -> 236 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("ARRAY", true) -0 -> 166 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("null", false) +0 -> 237 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("null", false) -0 -> 167 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("true", false) +0 -> 238 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("true", false) -0 -> 168 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("false", false) +0 -> 239 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("false", false) -0 -> 169 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("udf", false) +0 -> 240 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("udf", false) -0 -> 170 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["a", "z"], ["A", "Z"], "_"], false, false) +0 -> 241 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 171 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["a", "z"], ["A", "Z"], ["0", "9"], "_"], false, false) +0 -> 242 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["a", "z"], ["A", "Z"], "_"], false, false) -0 -> 173 member call = ???*0*["join"]("") +0 -> 243 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["a", "z"], ["A", "Z"], ["0", "9"], "_"], false, false) + +0 -> 245 member call = ???*0*["join"]("") - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 174 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("@", false) +0 -> 246 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 247 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("@", false) + +0 -> 248 call = (...) => input["substring"](peg$savedPos, peg$currPos)() + +0 -> 249 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 250 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("+", false) -0 -> 175 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +0 -> 251 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("~", false) -0 -> 176 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("+", false) +0 -> 252 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("\\", false) -0 -> 177 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("~", false) +0 -> 253 call = (...) => input["substring"](peg$savedPos, peg$currPos)() -0 -> 178 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("\\", false) +0 -> 254 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 179 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +0 -> 255 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 180 call = (...) => {"type": "any"}() +0 -> 256 call = (...) => {"type": "any"}() -0 -> 181 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("b", false) +0 -> 257 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("b", false) -0 -> 182 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("f", false) +0 -> 258 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 259 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("f", false) + +0 -> 260 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 261 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("n", false) + +0 -> 262 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 263 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("r", false) + +0 -> 264 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 183 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("n", false) +0 -> 265 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("t", false) -0 -> 184 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("r", false) +0 -> 266 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 185 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("t", false) +0 -> 267 call = (...) => input["substring"](peg$savedPos, peg$currPos)() -0 -> 186 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +0 -> 268 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 187 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("u", false) +0 -> 269 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("u", false) -0 -> 189 free var = FreeVar(String) +0 -> 271 free var = FreeVar(String) -0 -> 190 free var = FreeVar(parseInt) +0 -> 272 free var = FreeVar(parseInt) -0 -> 191 call = ???*0*(???*1*, 16) +0 -> 273 call = ???*0*(???*1*, 16) - *0* FreeVar(parseInt) ⚠️ unknown global ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 192 member call = ???*0*["fromCharCode"](???*1*) +0 -> 274 member call = ???*0*["fromCharCode"](???*1*) - *0* FreeVar(String) ⚠️ unknown global ⚠️ This value might have side effects @@ -550,9 +873,45 @@ ⚠️ unknown global ⚠️ This value might have side effects -0 -> 193 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["0", "9"], ["a", "f"]], false, true) +0 -> 275 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 276 call = (...) => {"type": "class", "parts": parts, "inverted": inverted, "ignoreCase": ignoreCase}([["0", "9"], ["a", "f"]], false, true) + +0 -> 277 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 278 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 279 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 280 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 281 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 282 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 283 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 284 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 195 member call = ???*0*["reduce"]( +0 -> 286 member call = ???*0*["reduce"]( (...) => {"type": "scalar_member_expression", "object": object, "property": property, "computed": computed}, ???*1* ) @@ -561,51 +920,83 @@ - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 196 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("?", false) +0 -> 287 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 288 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 197 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(":", false) +0 -> 289 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("?", false) -0 -> 198 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("??", false) +0 -> 290 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(":", false) -0 -> 199 call = (...) => tail["reduce"](*arrow function 169161*, head)(???*0*, ???*1*) +0 -> 291 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 292 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("??", false) + +0 -> 293 call = (...) => tail["reduce"](*arrow function 169161*, head)(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 200 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("=", false) +0 -> 294 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 201 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("!=", false) +0 -> 295 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("=", false) -0 -> 202 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<>", false) +0 -> 296 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("!=", false) -0 -> 203 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<=", false) +0 -> 297 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<>", false) -0 -> 204 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">=", false) +0 -> 298 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<=", false) -0 -> 205 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<", false) +0 -> 299 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">=", false) -0 -> 206 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">", false) +0 -> 300 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<", false) -0 -> 207 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("|", false) +0 -> 301 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">", false) -0 -> 208 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("^", false) +0 -> 302 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 303 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 304 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("|", false) -0 -> 209 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("&", false) +0 -> 305 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("^", false) -0 -> 210 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<<", false) +0 -> 306 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("&", false) -0 -> 211 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>>", false) +0 -> 307 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("<<", false) -0 -> 212 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>", false) +0 -> 308 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>>", false) -0 -> 213 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("||", false) +0 -> 309 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}(">>", false) -0 -> 214 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("/", false) +0 -> 310 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("||", false) -0 -> 215 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("%", false) +0 -> 311 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("/", false) + +0 -> 312 call = (...) => {"type": "literal", "text": text, "ignoreCase": ignoreCase}("%", false) + +0 -> 313 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 217 member call = ???*0*["reduce"]( +0 -> 314 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 316 member call = ???*0*["reduce"]( (...) => { "type": "collection_member_expression", "object": object, @@ -619,11 +1010,23 @@ - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 218 free var = FreeVar(Number) +0 -> 317 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 318 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 219 call = (...) => input["substring"](peg$savedPos, peg$currPos)() +0 -> 319 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 220 call = ???*0*(???*1*) +0 -> 320 free var = FreeVar(Number) + +0 -> 321 call = (...) => input["substring"](peg$savedPos, peg$currPos)() + +0 -> 322 call = ???*0*(???*1*) - *0* FreeVar(Number) ⚠️ unknown global ⚠️ This value might have side effects @@ -632,17 +1035,29 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 221 conditional = ???*0* +0 -> 323 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 324 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 223 conditional = !(???*0*) +0 -> 325 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 326 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 328 conditional = !(???*0*) - *0* unsupported expression ⚠️ This value might have side effects -223 -> 224 free var = FreeVar(Error) +328 -> 329 free var = FreeVar(Error) -0 -> 229 member call = ???*0*["substring"](???*1*, ???*2*) +0 -> 334 member call = ???*0*["substring"](???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached @@ -650,7 +1065,11 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 230 call = (...) => { +0 -> 335 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 336 call = (...) => { "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} }(???*0*, ???*1*) @@ -659,11 +1078,15 @@ - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 231 conditional = ???*0* +0 -> 337 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 338 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -231 -> 232 call = (...) => { +338 -> 339 call = (...) => { "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} }(???*0*, ???*1*) @@ -672,11 +1095,11 @@ - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 233 call = (...) => {"type": "other", "description": description}(???*0*) +0 -> 340 call = (...) => {"type": "other", "description": description}(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 235 member call = ???*0*["substring"](???*1*, ???*2*) +0 -> 342 member call = ???*0*["substring"](???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached @@ -684,7 +1107,7 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 236 call = (...) => ???*0*([{"type": "other", "description": ???*1*}], ???*2*, ???*4*) +0 -> 343 call = (...) => ???*0*([{"type": "other", "description": ???*1*}], ???*2*, ???*4*) - *0* unknown new expression ⚠️ This value might have side effects - *1* arguments[0] @@ -696,11 +1119,11 @@ - *4* max number of linking steps reached ⚠️ This value might have side effects -0 -> 237 conditional = ???*0* +0 -> 344 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -237 -> 238 call = (...) => { +344 -> 345 call = (...) => { "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} }(???*0*, ???*1*) @@ -709,7 +1132,7 @@ - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 239 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 346 call = (...) => ???*0*(???*1*, ???*2*) - *0* unknown new expression ⚠️ This value might have side effects - *1* arguments[0] @@ -717,7 +1140,27 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 241 conditional = ({"line": 1, "column": 1} | ???*0* | {"line": ???*2*, "column": ???*4*}) +0 -> 347 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 348 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 349 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 350 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 351 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 353 conditional = ({"line": 1, "column": 1} | ???*0* | {"line": ???*2*, "column": ???*4*}) - *0* [][???*1*] ⚠️ unknown array prototype methods or values - *1* arguments[0] @@ -731,7 +1174,11 @@ - *5* details ⚠️ circular variable reference -241 -> 247 member call = ???*0*["charCodeAt"]((???*1* | ???*2* | ???*3*)) +353 -> 354 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +353 -> 360 member call = ???*0*["charCodeAt"]((???*1* | ???*2* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* p @@ -741,127 +1188,155 @@ - *3* updated with update expression ⚠️ This value might have side effects -241 -> 248 conditional = (???*0* === 10) +353 -> 361 conditional = (???*0* === 10) - *0* ???*1*["charCodeAt"](p) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 253 call = (...) => (undefined | details)(???*0*) +353 -> 366 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 367 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 368 call = (...) => (undefined | details)(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 254 call = (...) => (undefined | details)(???*0*) +0 -> 369 call = (...) => (undefined | details)(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 260 member call = []["push"](???*0*) +0 -> 374 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 375 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 377 member call = []["push"](???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 262 member call = (...) => undefined["buildMessage"](???*0*, ???*1*) +0 -> 378 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 380 member call = (...) => undefined["buildMessage"](???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 263 call = (...) => s0() +0 -> 381 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 382 call = (...) => s0() -0 -> 264 conditional = ???*0* +0 -> 383 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -264 -> 265 call = (...) => s0() +383 -> 384 call = (...) => s0() -264 -> 266 conditional = ???*0* +383 -> 385 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -266 -> 267 call = (...) => s0() +385 -> 386 call = (...) => s0() -266 -> 268 conditional = ((???*0* | []) !== {}) +385 -> 387 conditional = ((???*0* | []) !== {}) - *0* s3 ⚠️ pattern without value -268 -> 269 call = (...) => {"type": "sql", "body": body}(???*0*) +387 -> 388 call = (...) => {"type": "sql", "body": body}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 270 call = (...) => s0() +0 -> 389 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 390 call = (...) => s0() -0 -> 271 conditional = ???*0* +0 -> 391 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -271 -> 272 call = (...) => s0() +391 -> 392 call = (...) => s0() -271 -> 273 conditional = ((???*0* | []) !== {}) +391 -> 393 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -273 -> 274 call = (...) => s0() +393 -> 394 call = (...) => s0() -273 -> 275 conditional = ???*0* +393 -> 395 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -275 -> 276 call = (...) => s0() +395 -> 396 call = (...) => s0() -275 -> 277 conditional = ???*0* +395 -> 397 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -277 -> 278 call = (...) => s0() +397 -> 398 call = (...) => s0() -277 -> 279 conditional = ???*0* +397 -> 399 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -279 -> 280 call = (...) => v(???*0*) +399 -> 400 call = (...) => v(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -273 -> 281 conditional = ???*0* +393 -> 401 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -281 -> 282 call = (...) => s0() +401 -> 402 call = (...) => s0() -281 -> 283 conditional = ???*0* +401 -> 403 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -283 -> 284 call = (...) => s0() +403 -> 404 call = (...) => s0() -283 -> 285 conditional = ???*0* +403 -> 405 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -285 -> 286 call = (...) => s0() +405 -> 406 call = (...) => s0() -285 -> 287 conditional = ???*0* +405 -> 407 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -287 -> 288 call = (...) => s0() +407 -> 408 call = (...) => s0() -287 -> 289 conditional = ???*0* +407 -> 409 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -289 -> 290 call = (...) => s0() +409 -> 410 call = (...) => s0() -289 -> 291 conditional = ???*0* +409 -> 411 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -291 -> 292 call = (...) => s0() +411 -> 412 call = (...) => s0() -291 -> 293 conditional = ???*0* +411 -> 413 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -293 -> 294 call = (...) => v(???*0*, ???*1*, ???*2*) +413 -> 414 call = (...) => v(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -869,35 +1344,35 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -287 -> 295 conditional = ???*0* +407 -> 415 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -295 -> 296 call = (...) => s0() +415 -> 416 call = (...) => s0() -295 -> 297 conditional = ???*0* +415 -> 417 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -297 -> 298 call = (...) => s0() +417 -> 418 call = (...) => s0() -297 -> 299 conditional = ???*0* +417 -> 419 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -299 -> 300 call = (...) => s0() +419 -> 420 call = (...) => s0() -299 -> 301 conditional = ???*0* +419 -> 421 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -301 -> 302 call = (...) => s0() +421 -> 422 call = (...) => s0() -301 -> 303 conditional = ???*0* +421 -> 423 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -303 -> 304 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*) +423 -> 424 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -907,47 +1382,47 @@ - *3* max number of linking steps reached ⚠️ This value might have side effects -297 -> 305 conditional = ???*0* +417 -> 425 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -305 -> 306 call = (...) => s0() +425 -> 426 call = (...) => s0() -305 -> 307 conditional = ???*0* +425 -> 427 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -307 -> 308 call = (...) => s0() +427 -> 428 call = (...) => s0() -307 -> 309 conditional = ???*0* +427 -> 429 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -309 -> 310 call = (...) => s0() +429 -> 430 call = (...) => s0() -309 -> 311 conditional = ((???*0* | []) !== {}) +429 -> 431 conditional = ((???*0* | []) !== {}) - *0* s13 ⚠️ pattern without value -311 -> 312 call = (...) => s0() +431 -> 432 call = (...) => s0() -311 -> 313 conditional = ???*0* +431 -> 433 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -313 -> 314 call = (...) => s0() +433 -> 434 call = (...) => s0() -313 -> 315 conditional = ((???*0* | []) !== {}) +433 -> 435 conditional = ((???*0* | []) !== {}) - *0* s15 ⚠️ pattern without value -315 -> 316 call = (...) => s0() +435 -> 436 call = (...) => s0() -315 -> 317 conditional = ???*0* +435 -> 437 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -317 -> 318 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +437 -> 438 call = (...) => v(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -959,11 +1434,11 @@ - *4* max number of linking steps reached ⚠️ This value might have side effects -307 -> 319 conditional = ???*0* +427 -> 439 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -319 -> 320 call = (...) => { +439 -> 440 call = (...) => { "type": "select_query", "top": top, "select": select, @@ -982,185 +1457,193 @@ - *4* max number of linking steps reached ⚠️ This value might have side effects -0 -> 322 member call = ???*0*["charCodeAt"](???*1*) +0 -> 441 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 443 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 323 conditional = (???*0* === 42) +0 -> 444 conditional = (???*0* === 42) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -323 -> 324 conditional = ((0 | ???*0*) === 0) +444 -> 445 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -324 -> 325 call = (...) => (undefined | FreeVar(undefined))( +445 -> 446 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "*", "ignoreCase": false} ) -0 -> 326 conditional = ???*0* +0 -> 447 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -326 -> 327 call = (...) => {"type": "select_specification", "*": true}() +447 -> 448 call = (...) => {"type": "select_specification", "*": true}() -0 -> 328 conditional = ???*0* +0 -> 449 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -328 -> 329 call = (...) => s0() +449 -> 450 call = (...) => s0() -328 -> 330 conditional = ???*0* +449 -> 451 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -330 -> 331 call = (...) => {"type": "select_specification", "properties": properties}(???*0*) +451 -> 452 call = (...) => {"type": "select_specification", "properties": properties}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -328 -> 332 conditional = ???*0* +449 -> 453 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -332 -> 333 call = (...) => s0() +453 -> 454 call = (...) => s0() -332 -> 334 conditional = ???*0* +453 -> 455 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -334 -> 335 call = (...) => s0() +455 -> 456 call = (...) => s0() -334 -> 336 conditional = ((???*0* | []) !== {}) +455 -> 457 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -336 -> 337 call = (...) => s0() +457 -> 458 call = (...) => s0() -336 -> 338 conditional = ???*0* +457 -> 459 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -338 -> 339 call = (...) => {"type": "select_specification", "value": value}(???*0*) +459 -> 460 call = (...) => {"type": "select_specification", "value": value}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 340 call = (...) => s0() +0 -> 461 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 341 conditional = ???*0* +0 -> 462 call = (...) => s0() + +0 -> 463 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -341 -> 342 call = (...) => s0() +463 -> 464 call = (...) => s0() -341 -> 343 conditional = ???*0* +463 -> 465 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -343 -> 345 member call = ???*0*["charCodeAt"](???*1*) +465 -> 467 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -343 -> 346 conditional = (???*0* === 44) +465 -> 468 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -346 -> 347 conditional = ((0 | ???*0*) === 0) +468 -> 469 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -347 -> 348 call = (...) => (undefined | FreeVar(undefined))( +469 -> 470 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -343 -> 349 conditional = ((???*0* | "," | {}) !== {}) +465 -> 471 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -349 -> 350 call = (...) => s0() +471 -> 472 call = (...) => s0() -349 -> 351 conditional = ((???*0* | []) !== {}) +471 -> 473 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -351 -> 352 call = (...) => s0() +473 -> 474 call = (...) => s0() -351 -> 353 conditional = ???*0* +473 -> 475 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -353 -> 354 call = (...) => v(???*0*, ???*1*) +475 -> 476 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -341 -> 356 member call = (???*0* | [])["push"](???*1*) +463 -> 478 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -341 -> 357 call = (...) => s0() +463 -> 479 call = (...) => s0() -341 -> 358 conditional = ???*0* +463 -> 480 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -358 -> 360 member call = ???*0*["charCodeAt"](???*1*) +480 -> 482 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -358 -> 361 conditional = (???*0* === 44) +480 -> 483 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -361 -> 362 conditional = ((0 | ???*0*) === 0) +483 -> 484 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -362 -> 363 call = (...) => (undefined | FreeVar(undefined))( +484 -> 485 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -358 -> 364 conditional = ((???*0* | "," | {}) !== {}) +480 -> 486 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -364 -> 365 call = (...) => s0() +486 -> 487 call = (...) => s0() -364 -> 366 conditional = ((???*0* | []) !== {}) +486 -> 488 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -366 -> 367 call = (...) => s0() +488 -> 489 call = (...) => s0() -366 -> 368 conditional = ???*0* +488 -> 490 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -368 -> 369 call = (...) => v(???*0*, ???*1*) +490 -> 491 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -341 -> 370 conditional = ((???*0* | []) !== {}) +463 -> 492 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -370 -> 371 call = (...) => {"type": "object_property_list", "properties": ???*0*}(???*1*, (???*2* | [])) +492 -> 493 call = (...) => {"type": "object_property_list", "properties": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1168,311 +1651,331 @@ - *2* s2 ⚠️ pattern without value -0 -> 372 call = (...) => s0() +0 -> 494 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 373 conditional = ???*0* +0 -> 495 call = (...) => s0() + +0 -> 496 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -373 -> 374 call = (...) => s0() +496 -> 497 call = (...) => s0() -373 -> 375 conditional = ???*0* +496 -> 498 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -375 -> 376 call = (...) => s0() +498 -> 499 call = (...) => s0() -375 -> 377 conditional = ???*0* +498 -> 500 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -377 -> 378 call = (...) => s0() +500 -> 501 call = (...) => s0() -377 -> 379 conditional = ((???*0* | []) !== {}) +500 -> 502 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -379 -> 380 call = (...) => s0() +502 -> 503 call = (...) => s0() -379 -> 381 conditional = ???*0* +502 -> 504 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -381 -> 382 call = (...) => v(???*0*, ???*1*) +504 -> 505 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -373 -> 384 member call = (???*0* | [])["push"](???*1*) +496 -> 507 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -373 -> 385 call = (...) => s0() +496 -> 508 call = (...) => s0() -373 -> 386 conditional = ???*0* +496 -> 509 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -386 -> 387 call = (...) => s0() +509 -> 510 call = (...) => s0() -386 -> 388 conditional = ???*0* +509 -> 511 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -388 -> 389 call = (...) => s0() +511 -> 512 call = (...) => s0() -388 -> 390 conditional = ((???*0* | []) !== {}) +511 -> 513 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -390 -> 391 call = (...) => s0() +513 -> 514 call = (...) => s0() -390 -> 392 conditional = ???*0* +513 -> 515 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -392 -> 393 call = (...) => v(???*0*, ???*1*) +515 -> 516 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -373 -> 394 conditional = ((???*0* | []) !== {}) +496 -> 517 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -394 -> 395 call = (...) => {"type": "from_specification", "source": source, "joins": joins}(???*0*, (???*1* | [])) +517 -> 518 call = (...) => {"type": "from_specification", "source": source, "joins": joins}(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 396 call = (...) => s0() +0 -> 519 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 520 call = (...) => s0() -0 -> 397 conditional = ???*0* +0 -> 521 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -397 -> 398 call = (...) => s0() +521 -> 522 call = (...) => s0() -397 -> 399 conditional = ???*0* +521 -> 523 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -399 -> 400 call = (...) => s0() +523 -> 524 call = (...) => s0() -399 -> 401 conditional = ???*0* +523 -> 525 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -401 -> 402 call = (...) => s0() +525 -> 526 call = (...) => s0() -401 -> 403 conditional = ???*0* +525 -> 527 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -403 -> 404 call = (...) => s0() +527 -> 528 call = (...) => s0() -403 -> 405 conditional = ???*0* +527 -> 529 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -405 -> 406 call = (...) => {"type": "from_source", "expression": expression, "alias": alias, "iteration": true}(???*0*, ???*1*) +529 -> 530 call = (...) => {"type": "from_source", "expression": expression, "alias": alias, "iteration": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 407 conditional = ???*0* +0 -> 531 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -407 -> 408 call = (...) => s0() +531 -> 532 call = (...) => s0() -407 -> 409 conditional = ???*0* +531 -> 533 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -409 -> 410 call = (...) => s0() +533 -> 534 call = (...) => s0() -409 -> 411 conditional = ???*0* +533 -> 535 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -411 -> 412 call = (...) => s0() +535 -> 536 call = (...) => s0() -409 -> 413 conditional = ???*0* +533 -> 537 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -413 -> 414 call = (...) => s0() +537 -> 538 call = (...) => s0() -413 -> 415 conditional = ???*0* +537 -> 539 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -415 -> 416 call = (...) => s0() +539 -> 540 call = (...) => s0() -415 -> 417 conditional = ???*0* +539 -> 541 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -417 -> 418 call = (...) => v(???*0*, ???*1*) +541 -> 542 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -409 -> 419 conditional = ???*0* +533 -> 543 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -419 -> 420 call = (...) => {"type": "from_source", "expression": expression, "alias": alias}(???*0*, ???*1*) +543 -> 544 call = (...) => {"type": "from_source", "expression": expression, "alias": alias}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 421 call = (...) => s0() +0 -> 545 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 546 call = (...) => s0() -0 -> 422 conditional = ???*0* +0 -> 547 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -422 -> 423 call = (...) => s0() +547 -> 548 call = (...) => s0() -422 -> 424 conditional = ???*0* +547 -> 549 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -424 -> 425 call = (...) => s0() +549 -> 550 call = (...) => s0() + +0 -> 551 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 426 call = (...) => s0() +0 -> 552 call = (...) => s0() -0 -> 427 conditional = ???*0* +0 -> 553 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -427 -> 428 call = (...) => {"type": "filter_condition", "condition": condition}(???*0*) +553 -> 554 call = (...) => {"type": "filter_condition", "condition": condition}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 429 call = (...) => s0() +0 -> 555 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 430 conditional = ???*0* +0 -> 556 call = (...) => s0() + +0 -> 557 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -430 -> 431 call = (...) => s0() +557 -> 558 call = (...) => s0() -430 -> 432 conditional = ???*0* +557 -> 559 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -432 -> 434 member call = ???*0*["charCodeAt"](???*1*) +559 -> 561 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -432 -> 435 conditional = (???*0* === 44) +559 -> 562 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -435 -> 436 conditional = ((0 | ???*0*) === 0) +562 -> 563 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -436 -> 437 call = (...) => (undefined | FreeVar(undefined))( +563 -> 564 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -432 -> 438 conditional = ((???*0* | "," | {}) !== {}) +559 -> 565 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -438 -> 439 call = (...) => s0() +565 -> 566 call = (...) => s0() -438 -> 440 conditional = ((???*0* | []) !== {}) +565 -> 567 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -440 -> 441 call = (...) => s0() +567 -> 568 call = (...) => s0() -440 -> 442 conditional = ???*0* +567 -> 569 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -442 -> 443 call = (...) => v(???*0*, ???*1*) +569 -> 570 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -430 -> 445 member call = (???*0* | [])["push"](???*1*) +557 -> 572 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -430 -> 446 call = (...) => s0() +557 -> 573 call = (...) => s0() -430 -> 447 conditional = ???*0* +557 -> 574 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -447 -> 449 member call = ???*0*["charCodeAt"](???*1*) +574 -> 576 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -447 -> 450 conditional = (???*0* === 44) +574 -> 577 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -450 -> 451 conditional = ((0 | ???*0*) === 0) +577 -> 578 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -451 -> 452 call = (...) => (undefined | FreeVar(undefined))( +578 -> 579 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -447 -> 453 conditional = ((???*0* | "," | {}) !== {}) +574 -> 580 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -453 -> 454 call = (...) => s0() +580 -> 581 call = (...) => s0() -453 -> 455 conditional = ((???*0* | []) !== {}) +580 -> 582 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -455 -> 456 call = (...) => s0() +582 -> 583 call = (...) => s0() -455 -> 457 conditional = ???*0* +582 -> 584 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -457 -> 458 call = (...) => v(???*0*, ???*1*) +584 -> 585 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -430 -> 459 conditional = ((???*0* | []) !== {}) +557 -> 586 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -459 -> 460 call = (...) => {"type": "sort_specification", "expressions": ???*0*}(???*1*, (???*2* | [])) +586 -> 587 call = (...) => {"type": "sort_specification", "expressions": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1480,433 +1983,445 @@ - *2* s2 ⚠️ pattern without value -0 -> 461 call = (...) => s0() +0 -> 588 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 589 call = (...) => s0() -0 -> 462 conditional = ???*0* +0 -> 590 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -462 -> 463 call = (...) => s0() +590 -> 591 call = (...) => s0() -462 -> 464 conditional = ???*0* +590 -> 592 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -464 -> 465 call = (...) => s0() +592 -> 593 call = (...) => s0() -464 -> 466 conditional = ???*0* +592 -> 594 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -466 -> 467 call = (...) => s0() +594 -> 595 call = (...) => s0() -464 -> 468 conditional = ???*0* +592 -> 596 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -468 -> 469 call = (...) => v(???*0*, ???*1*) +596 -> 597 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -462 -> 470 conditional = ???*0* +590 -> 598 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -470 -> 471 call = (...) => {"type": "sort_expression", "expression": expression, "order": order}(???*0*, ???*1*) +598 -> 599 call = (...) => {"type": "sort_expression", "expression": expression, "order": order}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 472 call = (...) => s0() +0 -> 600 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 473 conditional = ???*0* +0 -> 601 call = (...) => s0() + +0 -> 602 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -473 -> 474 call = (...) => s0() +602 -> 603 call = (...) => s0() -473 -> 475 conditional = ((???*0* | []) !== {}) +602 -> 604 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -475 -> 477 member call = ???*0*["charCodeAt"](???*1*) +604 -> 606 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -475 -> 478 conditional = (???*0* === 46) +604 -> 607 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -478 -> 479 conditional = ((0 | ???*0*) === 0) +607 -> 608 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -479 -> 480 call = (...) => (undefined | FreeVar(undefined))( +608 -> 609 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ".", "ignoreCase": false} ) -475 -> 481 conditional = ((???*0* | "." | {} | "(") !== {}) +604 -> 610 conditional = ((???*0* | "." | {} | "(") !== {}) - *0* s3 ⚠️ pattern without value -481 -> 482 call = (...) => s0() +610 -> 611 call = (...) => s0() -481 -> 483 conditional = ((???*0* | []) !== {}) +610 -> 612 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -483 -> 484 call = (...) => s0() +612 -> 613 call = (...) => s0() -483 -> 485 conditional = ???*0* +612 -> 614 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -485 -> 486 call = (...) => s0() +614 -> 615 call = (...) => s0() -485 -> 487 conditional = ((???*0* | []) !== {}) +614 -> 616 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -487 -> 489 member call = ???*0*["charCodeAt"](???*1*) +616 -> 618 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -487 -> 490 conditional = (???*0* === 40) +616 -> 619 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -490 -> 491 conditional = ((0 | ???*0*) === 0) +619 -> 620 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -491 -> 492 call = (...) => (undefined | FreeVar(undefined))( +620 -> 621 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "(", "ignoreCase": false} ) -487 -> 493 conditional = ((???*0* | "(" | {} | ")") !== {}) +616 -> 622 conditional = ((???*0* | "(" | {} | ")") !== {}) - *0* s7 ⚠️ pattern without value -493 -> 494 call = (...) => s0() +622 -> 623 call = (...) => s0() -493 -> 495 conditional = ((???*0* | []) !== {}) +622 -> 624 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -495 -> 496 call = (...) => s0() +624 -> 625 call = (...) => s0() -495 -> 497 conditional = ???*0* +624 -> 626 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -497 -> 498 call = (...) => s0() +626 -> 627 call = (...) => s0() -497 -> 499 conditional = ((???*0* | []) !== {}) +626 -> 628 conditional = ((???*0* | []) !== {}) - *0* s10 ⚠️ pattern without value -499 -> 501 member call = ???*0*["charCodeAt"](???*1*) +628 -> 630 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -499 -> 502 conditional = (???*0* === 41) +628 -> 631 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -502 -> 503 conditional = ((0 | ???*0*) === 0) +631 -> 632 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -503 -> 504 call = (...) => (undefined | FreeVar(undefined))( +632 -> 633 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ")", "ignoreCase": false} ) -499 -> 505 conditional = ((???*0* | ")" | {}) !== {}) +628 -> 634 conditional = ((???*0* | ")" | {}) !== {}) - *0* s11 ⚠️ pattern without value -505 -> 506 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args, "udf": true}(???*0*, ???*1*) +634 -> 635 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args, "udf": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 507 conditional = ???*0* +0 -> 636 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -507 -> 508 call = (...) => s0() +636 -> 637 call = (...) => s0() -507 -> 509 conditional = ???*0* +636 -> 638 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -509 -> 510 call = (...) => s0() +638 -> 639 call = (...) => s0() -509 -> 511 conditional = ((???*0* | []) !== {}) +638 -> 640 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -511 -> 513 member call = ???*0*["charCodeAt"](???*1*) +640 -> 642 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -511 -> 514 conditional = (???*0* === 40) +640 -> 643 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -514 -> 515 conditional = ((0 | ???*0*) === 0) +643 -> 644 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -515 -> 516 call = (...) => (undefined | FreeVar(undefined))( +644 -> 645 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "(", "ignoreCase": false} ) -511 -> 517 conditional = ((???*0* | "." | {} | "(") !== {}) +640 -> 646 conditional = ((???*0* | "." | {} | "(") !== {}) - *0* s3 ⚠️ pattern without value -517 -> 518 call = (...) => s0() +646 -> 647 call = (...) => s0() -517 -> 519 conditional = ((???*0* | []) !== {}) +646 -> 648 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -519 -> 520 call = (...) => s0() +648 -> 649 call = (...) => s0() -519 -> 521 conditional = ???*0* +648 -> 650 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -521 -> 522 call = (...) => s0() +650 -> 651 call = (...) => s0() -521 -> 523 conditional = ((???*0* | []) !== {}) +650 -> 652 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -523 -> 525 member call = ???*0*["charCodeAt"](???*1*) +652 -> 654 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -523 -> 526 conditional = (???*0* === 41) +652 -> 655 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -526 -> 527 conditional = ((0 | ???*0*) === 0) +655 -> 656 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -527 -> 528 call = (...) => (undefined | FreeVar(undefined))( +656 -> 657 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ")", "ignoreCase": false} ) -523 -> 529 conditional = ((???*0* | "(" | {} | ")") !== {}) +652 -> 658 conditional = ((???*0* | "(" | {} | ")") !== {}) - *0* s7 ⚠️ pattern without value -529 -> 530 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args}(???*0*, ???*1*) +658 -> 659 call = (...) => {"type": "scalar_function_expression", "name": name, "arguments": args}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 532 member call = ???*0*["charCodeAt"](???*1*) +0 -> 660 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 662 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 533 conditional = (???*0* === 123) +0 -> 663 conditional = (???*0* === 123) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -533 -> 534 conditional = ((0 | ???*0*) === 0) +663 -> 664 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -534 -> 535 call = (...) => (undefined | FreeVar(undefined))( +664 -> 665 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "{", "ignoreCase": false} ) -0 -> 536 conditional = ???*0* +0 -> 666 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -536 -> 537 call = (...) => s0() +666 -> 667 call = (...) => s0() -536 -> 538 conditional = ((???*0* | []) !== {}) +666 -> 668 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -538 -> 539 call = (...) => s0() +668 -> 669 call = (...) => s0() -538 -> 540 conditional = ???*0* +668 -> 670 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -540 -> 541 call = (...) => s0() +670 -> 671 call = (...) => s0() -540 -> 542 conditional = ???*0* +670 -> 672 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -542 -> 544 member call = ???*0*["charCodeAt"](???*1*) +672 -> 674 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -542 -> 545 conditional = (???*0* === 44) +672 -> 675 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -545 -> 546 conditional = ((0 | ???*0*) === 0) +675 -> 676 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -546 -> 547 call = (...) => (undefined | FreeVar(undefined))( +676 -> 677 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -542 -> 548 conditional = ((???*0* | "," | {}) !== {}) +672 -> 678 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -548 -> 549 call = (...) => s0() +678 -> 679 call = (...) => s0() -548 -> 550 conditional = ((???*0* | []) !== {}) +678 -> 680 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -550 -> 551 call = (...) => s0() +680 -> 681 call = (...) => s0() -550 -> 552 conditional = ???*0* +680 -> 682 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -552 -> 553 call = (...) => v(???*0*, ???*1*) +682 -> 683 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -540 -> 555 member call = (???*0* | [])["push"](???*1*) +670 -> 685 member call = (???*0* | [])["push"](???*1*) - *0* s4 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -540 -> 556 call = (...) => s0() +670 -> 686 call = (...) => s0() -540 -> 557 conditional = ???*0* +670 -> 687 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -557 -> 559 member call = ???*0*["charCodeAt"](???*1*) +687 -> 689 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -557 -> 560 conditional = (???*0* === 44) +687 -> 690 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -560 -> 561 conditional = ((0 | ???*0*) === 0) +690 -> 691 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -561 -> 562 call = (...) => (undefined | FreeVar(undefined))( +691 -> 692 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -557 -> 563 conditional = ((???*0* | "," | {}) !== {}) +687 -> 693 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -563 -> 564 call = (...) => s0() +693 -> 694 call = (...) => s0() -563 -> 565 conditional = ((???*0* | []) !== {}) +693 -> 695 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -565 -> 566 call = (...) => s0() +695 -> 696 call = (...) => s0() -565 -> 567 conditional = ???*0* +695 -> 697 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -567 -> 568 call = (...) => v(???*0*, ???*1*) +697 -> 698 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -540 -> 569 conditional = ((???*0* | []) !== {}) +670 -> 699 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -569 -> 570 call = (...) => s0() +699 -> 700 call = (...) => s0() -569 -> 571 conditional = ???*0* +699 -> 701 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -571 -> 573 member call = ???*0*["charCodeAt"](???*1*) +701 -> 703 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -571 -> 574 conditional = (???*0* === 125) +701 -> 704 conditional = (???*0* === 125) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -574 -> 575 conditional = ((0 | ???*0*) === 0) +704 -> 705 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -575 -> 576 call = (...) => (undefined | FreeVar(undefined))( +705 -> 706 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "}", "ignoreCase": false} ) -571 -> 577 conditional = ???*0* +701 -> 707 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -577 -> 578 call = (...) => {"type": "scalar_object_expression", "properties": (head ? ???*0* : [])}(???*1*, (???*2* | [])) +707 -> 708 call = (...) => {"type": "scalar_object_expression", "properties": (head ? ???*0* : [])}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -1914,189 +2429,213 @@ - *2* s4 ⚠️ pattern without value -0 -> 580 member call = ???*0*["charCodeAt"](???*1*) +0 -> 709 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 711 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 581 conditional = (???*0* === 91) +0 -> 712 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -581 -> 582 conditional = ((0 | ???*0*) === 0) +712 -> 713 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -582 -> 583 call = (...) => (undefined | FreeVar(undefined))( +713 -> 714 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "[", "ignoreCase": false} ) -0 -> 584 conditional = ???*0* +0 -> 715 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -584 -> 585 call = (...) => s0() +715 -> 716 call = (...) => s0() -584 -> 586 conditional = ((???*0* | []) !== {}) +715 -> 717 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -586 -> 587 call = (...) => s0() +717 -> 718 call = (...) => s0() -586 -> 588 conditional = ???*0* +717 -> 719 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -588 -> 589 call = (...) => s0() +719 -> 720 call = (...) => s0() -588 -> 590 conditional = ((???*0* | []) !== {}) +719 -> 721 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -590 -> 592 member call = ???*0*["charCodeAt"](???*1*) +721 -> 723 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -590 -> 593 conditional = (???*0* === 93) +721 -> 724 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -593 -> 594 conditional = ((0 | ???*0*) === 0) +724 -> 725 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -594 -> 595 call = (...) => (undefined | FreeVar(undefined))( +725 -> 726 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "]", "ignoreCase": false} ) -590 -> 596 conditional = ((???*0* | "]" | {}) !== {}) +721 -> 727 conditional = ((???*0* | "]" | {}) !== {}) - *0* s5 ⚠️ pattern without value -596 -> 597 call = (...) => {"type": "scalar_array_expression", "elements": elements}(???*0*) +727 -> 728 call = (...) => {"type": "scalar_array_expression", "elements": elements}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 598 call = (...) => s0() +0 -> 729 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 730 call = (...) => s0() -0 -> 599 conditional = ???*0* +0 -> 731 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -599 -> 600 call = (...) => s0() +731 -> 732 call = (...) => s0() -599 -> 601 conditional = ???*0* +731 -> 733 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -601 -> 602 call = (...) => s0() +733 -> 734 call = (...) => s0() -601 -> 603 conditional = ???*0* +733 -> 735 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -603 -> 604 call = (...) => s0() +735 -> 736 call = (...) => s0() -603 -> 605 conditional = ???*0* +735 -> 737 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -605 -> 606 call = (...) => s0() +737 -> 738 call = (...) => s0() -605 -> 607 conditional = ???*0* +737 -> 739 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -607 -> 608 call = (...) => s0() +739 -> 740 call = (...) => s0() -607 -> 609 conditional = ???*0* +739 -> 741 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -609 -> 610 call = (...) => s0() +741 -> 742 call = (...) => s0() + +0 -> 743 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 612 member call = ???*0*["substr"](???*1*, 9) +0 -> 745 member call = ???*0*["substr"](???*1*, 9) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 613 conditional = (???*0* === "undefined") +0 -> 746 conditional = (???*0* === "undefined") - *0* ???*1*["substr"](peg$currPos, 9) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -613 -> 614 conditional = ((0 | ???*0*) === 0) +746 -> 747 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -614 -> 615 call = (...) => (undefined | FreeVar(undefined))( +747 -> 748 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "undefined", "ignoreCase": false} ) -0 -> 616 conditional = ((???*0* | "undefined" | {} | {"type": "undefined_constant"}) !== {}) +0 -> 749 conditional = ((???*0* | "undefined" | {} | {"type": "undefined_constant"}) !== {}) - *0* s1 ⚠️ pattern without value -616 -> 617 call = (...) => {"type": "undefined_constant"}() +749 -> 750 call = (...) => {"type": "undefined_constant"}() + +0 -> 751 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 618 call = (...) => s0() +0 -> 752 call = (...) => s0() -0 -> 619 conditional = ???*0* +0 -> 753 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -619 -> 620 call = (...) => {"type": "null_constant"}() +753 -> 754 call = (...) => {"type": "null_constant"}() -0 -> 621 call = (...) => s0() +0 -> 755 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 756 call = (...) => s0() -0 -> 622 conditional = ???*0* +0 -> 757 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -622 -> 623 call = (...) => {"type": "boolean_constant", "value": false}() +757 -> 758 call = (...) => {"type": "boolean_constant", "value": false}() -0 -> 624 conditional = ???*0* +0 -> 759 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -624 -> 625 call = (...) => s0() +759 -> 760 call = (...) => s0() -624 -> 626 conditional = ???*0* +759 -> 761 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -626 -> 627 call = (...) => {"type": "boolean_constant", "value": true}() +761 -> 762 call = (...) => {"type": "boolean_constant", "value": true}() -0 -> 629 member call = ???*0*["charCodeAt"](???*1*) +0 -> 763 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 765 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 630 conditional = (???*0* === 45) +0 -> 766 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -630 -> 631 conditional = ((0 | ???*0*) === 0) +766 -> 767 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -631 -> 632 call = (...) => (undefined | FreeVar(undefined))( +767 -> 768 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "-", "ignoreCase": false} ) -0 -> 633 conditional = ((???*0* | "-" | {} | null | {"type": "number_constant", "value": ???*1*}) !== {}) +0 -> 769 conditional = ((???*0* | "-" | {} | null | {"type": "number_constant", "value": ???*1*}) !== {}) - *0* s1 ⚠️ pattern without value - *1* ((???*2* | "0x" | {} | null) ? ???*3* : ???*5*) @@ -2116,129 +2655,129 @@ ⚠️ unknown global ⚠️ This value might have side effects -633 -> 635 member call = ???*0*["substr"](???*1*, 2) +769 -> 771 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -633 -> 636 conditional = (???*0* === "0x") +769 -> 772 conditional = (???*0* === "0x") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -636 -> 637 conditional = ((0 | ???*0*) === 0) +772 -> 773 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -637 -> 638 call = (...) => (undefined | FreeVar(undefined))( +773 -> 774 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "0x", "ignoreCase": false} ) -633 -> 639 conditional = ((???*0* | "0x" | {} | null) !== {}) +769 -> 775 conditional = ((???*0* | "0x" | {} | null) !== {}) - *0* s2 ⚠️ pattern without value -639 -> 642 member call = ???*0*["charAt"](???*1*) +775 -> 778 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -639 -> 643 member call = /^[0-9]/["test"](???*0*) +775 -> 779 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -639 -> 644 conditional = /^[0-9]/["test"](???*0*) +775 -> 780 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -644 -> 646 member call = ???*0*["charAt"](???*1*) +780 -> 782 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -644 -> 647 conditional = ((0 | ???*0*) === 0) +780 -> 783 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -647 -> 648 call = (...) => (undefined | FreeVar(undefined))( +783 -> 784 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -639 -> 649 conditional = ???*0* +775 -> 785 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -649 -> 651 member call = (???*0* | [] | {})["push"](???*1*) +785 -> 787 member call = (???*0* | [] | {})["push"](???*1*) - *0* s3 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -649 -> 654 member call = ???*0*["charAt"](???*1*) +785 -> 790 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -649 -> 655 member call = /^[0-9]/["test"](???*0*) +785 -> 791 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -649 -> 656 conditional = /^[0-9]/["test"](???*0*) +785 -> 792 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -656 -> 658 member call = ???*0*["charAt"](???*1*) +792 -> 794 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -656 -> 659 conditional = ((0 | ???*0*) === 0) +792 -> 795 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -659 -> 660 call = (...) => (undefined | FreeVar(undefined))( +795 -> 796 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -639 -> 661 conditional = ((???*0* | [] | {}) !== {}) +775 -> 797 conditional = ((???*0* | [] | {}) !== {}) - *0* s3 ⚠️ pattern without value -661 -> 663 member call = ???*0*["charCodeAt"](???*1*) +797 -> 799 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -661 -> 664 conditional = (???*0* === 46) +797 -> 800 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -664 -> 665 conditional = ((0 | ???*0*) === 0) +800 -> 801 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -665 -> 666 call = (...) => (undefined | FreeVar(undefined))( +801 -> 802 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ".", "ignoreCase": false} ) -661 -> 667 conditional = ((???*0* | "." | {} | [???*1*, (???*2* | [] | {})]) !== {}) +797 -> 803 conditional = ((???*0* | "." | {} | [???*1*, (???*2* | [] | {})]) !== {}) - *0* s5 ⚠️ pattern without value - *1* s5 @@ -2246,39 +2785,39 @@ - *2* s6 ⚠️ pattern without value -667 -> 670 member call = ???*0*["charAt"](???*1*) +803 -> 806 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -667 -> 671 member call = /^[0-9]/["test"](???*0*) +803 -> 807 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -667 -> 672 conditional = /^[0-9]/["test"](???*0*) +803 -> 808 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -672 -> 674 member call = ???*0*["charAt"](???*1*) +808 -> 810 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -672 -> 675 conditional = ((0 | ???*0*) === 0) +808 -> 811 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -675 -> 676 call = (...) => (undefined | FreeVar(undefined))( +811 -> 812 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -667 -> 677 conditional = ((???*0* | ???*1* | {}) !== {}) +803 -> 813 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s7 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -2286,7 +2825,7 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -677 -> 679 member call = (???*0* | [] | {})["push"]((???*1* | ???*2* | {})) +813 -> 815 member call = (???*0* | [] | {})["push"]((???*1* | ???*2* | {})) - *0* s6 ⚠️ pattern without value - *1* s7 @@ -2296,70 +2835,74 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -677 -> 682 member call = ???*0*["charAt"](???*1*) +813 -> 818 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -677 -> 683 member call = /^[0-9]/["test"](???*0*) +813 -> 819 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -677 -> 684 conditional = /^[0-9]/["test"](???*0*) +813 -> 820 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -684 -> 686 member call = ???*0*["charAt"](???*1*) +820 -> 822 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -684 -> 687 conditional = ((0 | ???*0*) === 0) +820 -> 823 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -687 -> 688 call = (...) => (undefined | FreeVar(undefined))( +823 -> 824 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -661 -> 689 conditional = ???*0* +797 -> 825 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -689 -> 690 call = (...) => { +825 -> 826 call = (...) => { "type": "number_constant", "value": (hex ? FreeVar(parseInt)(text(), 16) : FreeVar(parseFloat)(text())) }((???*0* | "0x" | {} | null)) - *0* s2 ⚠️ pattern without value -0 -> 692 member call = ???*0*["charCodeAt"](???*1*) +0 -> 827 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 829 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 693 conditional = (???*0* === 34) +0 -> 830 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -693 -> 694 conditional = ((0 | ???*0*) === 0) +830 -> 831 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -694 -> 695 call = (...) => (undefined | FreeVar(undefined))( +831 -> 832 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\"", "ignoreCase": false} ) -0 -> 696 conditional = (( +0 -> 833 conditional = (( | ???*0* | "\"" | {} @@ -2377,73 +2920,73 @@ - *4* []["join"] ⚠️ non-num constant property on array -696 -> 697 call = (...) => s0() +833 -> 834 call = (...) => s0() -696 -> 699 member call = (???*0* | [])["push"](???*1*) +833 -> 836 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -696 -> 700 call = (...) => s0() +833 -> 837 call = (...) => s0() -696 -> 701 conditional = ((???*0* | []) !== {}) +833 -> 838 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -701 -> 703 member call = ???*0*["charCodeAt"](???*1*) +838 -> 840 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -701 -> 704 conditional = (???*0* === 34) +838 -> 841 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -704 -> 705 conditional = ((0 | ???*0*) === 0) +841 -> 842 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -705 -> 706 call = (...) => (undefined | FreeVar(undefined))( +842 -> 843 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\"", "ignoreCase": false} ) -701 -> 707 conditional = ???*0* +838 -> 844 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -707 -> 708 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) +844 -> 845 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) - *0* s2 ⚠️ pattern without value -0 -> 709 conditional = ???*0* +0 -> 846 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -709 -> 711 member call = ???*0*["charCodeAt"](???*1*) +846 -> 848 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -709 -> 712 conditional = (???*0* === 39) +846 -> 849 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -712 -> 713 conditional = ((0 | ???*0*) === 0) +849 -> 850 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -713 -> 714 call = (...) => (undefined | FreeVar(undefined))( +850 -> 851 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "'", "ignoreCase": false} ) -709 -> 715 conditional = (( +846 -> 852 conditional = (( | ???*0* | "\"" | {} @@ -2461,221 +3004,225 @@ - *4* []["join"] ⚠️ non-num constant property on array -715 -> 716 call = (...) => s0() +852 -> 853 call = (...) => s0() -715 -> 718 member call = (???*0* | [])["push"](???*1*) +852 -> 855 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -715 -> 719 call = (...) => s0() +852 -> 856 call = (...) => s0() -715 -> 720 conditional = ((???*0* | []) !== {}) +852 -> 857 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -720 -> 722 member call = ???*0*["charCodeAt"](???*1*) +857 -> 859 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -720 -> 723 conditional = (???*0* === 39) +857 -> 860 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -723 -> 724 conditional = ((0 | ???*0*) === 0) +860 -> 861 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -724 -> 725 call = (...) => (undefined | FreeVar(undefined))( +861 -> 862 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "'", "ignoreCase": false} ) -720 -> 726 conditional = ???*0* +857 -> 863 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -726 -> 727 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) +863 -> 864 call = (...) => {"type": "string_constant", "value": chars["join"]("")}((???*0* | [])) - *0* s2 ⚠️ pattern without value -0 -> 729 member call = ???*0*["charCodeAt"](???*1*) +0 -> 865 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 867 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 730 conditional = (???*0* === 91) +0 -> 868 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -730 -> 731 conditional = ((0 | ???*0*) === 0) +868 -> 869 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -731 -> 732 call = (...) => (undefined | FreeVar(undefined))( +869 -> 870 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "[", "ignoreCase": false} ) -0 -> 733 conditional = ???*0* +0 -> 871 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -733 -> 734 call = (...) => s0() +871 -> 872 call = (...) => s0() -733 -> 735 conditional = ((???*0* | []) !== {}) +871 -> 873 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -735 -> 736 call = (...) => s0() +873 -> 874 call = (...) => s0() -735 -> 737 conditional = ???*0* +873 -> 875 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -737 -> 738 call = (...) => s0() +875 -> 876 call = (...) => s0() -737 -> 739 conditional = ???*0* +875 -> 877 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -739 -> 741 member call = ???*0*["charCodeAt"](???*1*) +877 -> 879 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -739 -> 742 conditional = (???*0* === 44) +877 -> 880 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -742 -> 743 conditional = ((0 | ???*0*) === 0) +880 -> 881 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -743 -> 744 call = (...) => (undefined | FreeVar(undefined))( +881 -> 882 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -739 -> 745 conditional = ((???*0* | "," | {}) !== {}) +877 -> 883 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -745 -> 746 call = (...) => s0() +883 -> 884 call = (...) => s0() -745 -> 747 conditional = ((???*0* | []) !== {}) +883 -> 885 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -747 -> 748 call = (...) => s0() +885 -> 886 call = (...) => s0() -747 -> 749 conditional = ???*0* +885 -> 887 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -749 -> 750 call = (...) => v(???*0*, ???*1*) +887 -> 888 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -737 -> 752 member call = (???*0* | [])["push"](???*1*) +875 -> 890 member call = (???*0* | [])["push"](???*1*) - *0* s4 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -737 -> 753 call = (...) => s0() +875 -> 891 call = (...) => s0() -737 -> 754 conditional = ???*0* +875 -> 892 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -754 -> 756 member call = ???*0*["charCodeAt"](???*1*) +892 -> 894 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -754 -> 757 conditional = (???*0* === 44) +892 -> 895 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -757 -> 758 conditional = ((0 | ???*0*) === 0) +895 -> 896 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -758 -> 759 call = (...) => (undefined | FreeVar(undefined))( +896 -> 897 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -754 -> 760 conditional = ((???*0* | "," | {}) !== {}) +892 -> 898 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -760 -> 761 call = (...) => s0() +898 -> 899 call = (...) => s0() -760 -> 762 conditional = ((???*0* | []) !== {}) +898 -> 900 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -762 -> 763 call = (...) => s0() +900 -> 901 call = (...) => s0() -762 -> 764 conditional = ???*0* +900 -> 902 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -764 -> 765 call = (...) => v(???*0*, ???*1*) +902 -> 903 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -737 -> 766 conditional = ((???*0* | []) !== {}) +875 -> 904 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -766 -> 767 call = (...) => s0() +904 -> 905 call = (...) => s0() -766 -> 768 conditional = ???*0* +904 -> 906 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -768 -> 770 member call = ???*0*["charCodeAt"](???*1*) +906 -> 908 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -768 -> 771 conditional = (???*0* === 93) +906 -> 909 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -771 -> 772 conditional = ((0 | ???*0*) === 0) +909 -> 910 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -772 -> 773 call = (...) => (undefined | FreeVar(undefined))( +910 -> 911 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "]", "ignoreCase": false} ) -768 -> 774 conditional = ???*0* +906 -> 912 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -774 -> 775 call = (...) => {"type": "array_constant", "elements": ???*0*}(???*1*, (???*2* | [])) +912 -> 913 call = (...) => {"type": "array_constant", "elements": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -2683,179 +3230,183 @@ - *2* s4 ⚠️ pattern without value -0 -> 777 member call = ???*0*["charCodeAt"](???*1*) +0 -> 914 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 916 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 778 conditional = (???*0* === 123) +0 -> 917 conditional = (???*0* === 123) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -778 -> 779 conditional = ((0 | ???*0*) === 0) +917 -> 918 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -779 -> 780 call = (...) => (undefined | FreeVar(undefined))( +918 -> 919 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "{", "ignoreCase": false} ) -0 -> 781 conditional = ???*0* +0 -> 920 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -781 -> 782 call = (...) => s0() +920 -> 921 call = (...) => s0() -781 -> 783 conditional = ((???*0* | []) !== {}) +920 -> 922 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -783 -> 784 call = (...) => s0() +922 -> 923 call = (...) => s0() -783 -> 785 conditional = ???*0* +922 -> 924 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -785 -> 786 call = (...) => s0() +924 -> 925 call = (...) => s0() -785 -> 787 conditional = ???*0* +924 -> 926 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -787 -> 789 member call = ???*0*["charCodeAt"](???*1*) +926 -> 928 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -787 -> 790 conditional = (???*0* === 44) +926 -> 929 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -790 -> 791 conditional = ((0 | ???*0*) === 0) +929 -> 930 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -791 -> 792 call = (...) => (undefined | FreeVar(undefined))( +930 -> 931 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -787 -> 793 conditional = ((???*0* | "," | {}) !== {}) +926 -> 932 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -793 -> 794 call = (...) => s0() +932 -> 933 call = (...) => s0() -793 -> 795 conditional = ((???*0* | []) !== {}) +932 -> 934 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -795 -> 796 call = (...) => s0() +934 -> 935 call = (...) => s0() -795 -> 797 conditional = ???*0* +934 -> 936 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -797 -> 798 call = (...) => v(???*0*, ???*1*) +936 -> 937 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -785 -> 800 member call = (???*0* | [])["push"](???*1*) +924 -> 939 member call = (???*0* | [])["push"](???*1*) - *0* s4 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -785 -> 801 call = (...) => s0() +924 -> 940 call = (...) => s0() -785 -> 802 conditional = ???*0* +924 -> 941 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -802 -> 804 member call = ???*0*["charCodeAt"](???*1*) +941 -> 943 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -802 -> 805 conditional = (???*0* === 44) +941 -> 944 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -805 -> 806 conditional = ((0 | ???*0*) === 0) +944 -> 945 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -806 -> 807 call = (...) => (undefined | FreeVar(undefined))( +945 -> 946 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -802 -> 808 conditional = ((???*0* | "," | {}) !== {}) +941 -> 947 conditional = ((???*0* | "," | {}) !== {}) - *0* s7 ⚠️ pattern without value -808 -> 809 call = (...) => s0() +947 -> 948 call = (...) => s0() -808 -> 810 conditional = ((???*0* | []) !== {}) +947 -> 949 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -810 -> 811 call = (...) => s0() +949 -> 950 call = (...) => s0() -810 -> 812 conditional = ???*0* +949 -> 951 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -812 -> 813 call = (...) => v(???*0*, ???*1*) +951 -> 952 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -785 -> 814 conditional = ((???*0* | []) !== {}) +924 -> 953 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -814 -> 815 call = (...) => s0() +953 -> 954 call = (...) => s0() -814 -> 816 conditional = ???*0* +953 -> 955 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -816 -> 818 member call = ???*0*["charCodeAt"](???*1*) +955 -> 957 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -816 -> 819 conditional = (???*0* === 125) +955 -> 958 conditional = (???*0* === 125) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -819 -> 820 conditional = ((0 | ???*0*) === 0) +958 -> 959 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -820 -> 821 call = (...) => (undefined | FreeVar(undefined))( +959 -> 960 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "}", "ignoreCase": false} ) -816 -> 822 conditional = ???*0* +955 -> 961 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -822 -> 823 call = (...) => {"type": "object_constant", "properties": ???*0*}(???*1*, (???*2* | [])) +961 -> 962 call = (...) => {"type": "object_constant", "properties": ???*0*}(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -2863,81 +3414,93 @@ - *2* s4 ⚠️ pattern without value -0 -> 824 call = (...) => s0() +0 -> 963 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 964 call = (...) => s0() -0 -> 825 conditional = ???*0* +0 -> 965 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -825 -> 826 call = (...) => s0() +965 -> 966 call = (...) => s0() -0 -> 828 member call = (???*0* | [])["push"](???*1*) +0 -> 968 member call = (???*0* | [])["push"](???*1*) - *0* s0 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 829 call = (...) => s0() +0 -> 969 call = (...) => s0() -0 -> 830 conditional = ???*0* +0 -> 970 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -830 -> 831 call = (...) => s0() +970 -> 971 call = (...) => s0() + +0 -> 972 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 834 member call = ???*0*["charAt"](???*1*) +0 -> 975 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 835 member call = /^[ \t\n\r]/["test"](???*0*) +0 -> 976 member call = /^[ \t\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 836 conditional = /^[ \t\n\r]/["test"](???*0*) +0 -> 977 conditional = /^[ \t\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -836 -> 838 member call = ???*0*["charAt"](???*1*) +977 -> 979 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -836 -> 839 conditional = ((0 | ???*0*) === 0) +977 -> 980 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -839 -> 840 call = (...) => (undefined | FreeVar(undefined))( +980 -> 981 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [" ", "\t", "\n", "\r"], "inverted": false, "ignoreCase": false} ) -0 -> 842 member call = ???*0*["substr"](???*1*, 2) +0 -> 982 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 984 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 843 conditional = (???*0* === "--") +0 -> 985 conditional = (???*0* === "--") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -843 -> 844 conditional = ((0 | ???*0*) === 0) +985 -> 986 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -844 -> 845 call = (...) => (undefined | FreeVar(undefined))( +986 -> 987 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "--", "ignoreCase": false} ) -0 -> 846 conditional = ((???*0* | "--" | {} | [???*1*, (???*2* | [])]) !== {}) +0 -> 988 conditional = ((???*0* | "--" | {} | [???*1*, (???*2* | [])]) !== {}) - *0* s1 ⚠️ pattern without value - *1* s1 @@ -2945,101 +3508,105 @@ - *2* s2 ⚠️ pattern without value -846 -> 849 member call = ???*0*["charAt"](???*1*) +988 -> 991 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -846 -> 850 member call = /^[\n\r]/["test"](???*0*) +988 -> 992 member call = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -846 -> 851 conditional = /^[\n\r]/["test"](???*0*) +988 -> 993 conditional = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -851 -> 853 member call = ???*0*["charAt"](???*1*) +993 -> 995 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -851 -> 854 conditional = ((0 | ???*0*) === 0) +993 -> 996 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -854 -> 855 call = (...) => (undefined | FreeVar(undefined))( +996 -> 997 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": ["\n", "\r"], "inverted": false, "ignoreCase": false} ) -846 -> 856 conditional = ???*0* +988 -> 998 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -856 -> 857 call = (...) => s0() +998 -> 999 call = (...) => s0() -846 -> 859 member call = (???*0* | [])["push"](???*1*) +988 -> 1001 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -846 -> 862 member call = ???*0*["charAt"](???*1*) +988 -> 1004 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -846 -> 863 member call = /^[\n\r]/["test"](???*0*) +988 -> 1005 member call = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -846 -> 864 conditional = /^[\n\r]/["test"](???*0*) +988 -> 1006 conditional = /^[\n\r]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -864 -> 866 member call = ???*0*["charAt"](???*1*) +1006 -> 1008 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -864 -> 867 conditional = ((0 | ???*0*) === 0) +1006 -> 1009 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -867 -> 868 call = (...) => (undefined | FreeVar(undefined))( +1009 -> 1010 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": ["\n", "\r"], "inverted": false, "ignoreCase": false} ) -846 -> 869 conditional = ???*0* +988 -> 1011 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -869 -> 870 call = (...) => s0() +1011 -> 1012 call = (...) => s0() + +0 -> 1013 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 873 member call = ???*0*["substr"](???*1*, 6) +0 -> 1016 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 874 member call = ???*0*["toLowerCase"]() +0 -> 1017 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 6) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 875 conditional = (???*0* === "select") +0 -> 1018 conditional = (???*0* === "select") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3049,39 +3616,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -875 -> 877 member call = ???*0*["substr"](???*1*, 6) +1018 -> 1020 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -875 -> 878 conditional = ((0 | ???*0*) === 0) +1018 -> 1021 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -878 -> 879 call = (...) => (undefined | FreeVar(undefined))( +1021 -> 1022 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "SELECT", "ignoreCase": true} ) -0 -> 880 conditional = ???*0* +0 -> 1023 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -880 -> 881 call = (...) => s0() +1023 -> 1024 call = (...) => s0() -0 -> 884 member call = ???*0*["substr"](???*1*, 3) +0 -> 1025 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1028 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 885 member call = ???*0*["toLowerCase"]() +0 -> 1029 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 886 conditional = (???*0* === "top") +0 -> 1030 conditional = (???*0* === "top") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3091,39 +3662,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -886 -> 888 member call = ???*0*["substr"](???*1*, 3) +1030 -> 1032 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -886 -> 889 conditional = ((0 | ???*0*) === 0) +1030 -> 1033 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -889 -> 890 call = (...) => (undefined | FreeVar(undefined))( +1033 -> 1034 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "TOP", "ignoreCase": true} ) -0 -> 891 conditional = ???*0* +0 -> 1035 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -891 -> 892 call = (...) => s0() +1035 -> 1036 call = (...) => s0() + +0 -> 1037 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 895 member call = ???*0*["substr"](???*1*, 4) +0 -> 1040 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 896 member call = ???*0*["toLowerCase"]() +0 -> 1041 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 897 conditional = (???*0* === "from") +0 -> 1042 conditional = (???*0* === "from") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3133,39 +3708,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -897 -> 899 member call = ???*0*["substr"](???*1*, 4) +1042 -> 1044 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -897 -> 900 conditional = ((0 | ???*0*) === 0) +1042 -> 1045 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -900 -> 901 call = (...) => (undefined | FreeVar(undefined))( +1045 -> 1046 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "FROM", "ignoreCase": true} ) -0 -> 902 conditional = ???*0* +0 -> 1047 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -902 -> 903 call = (...) => s0() +1047 -> 1048 call = (...) => s0() + +0 -> 1049 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 906 member call = ???*0*["substr"](???*1*, 5) +0 -> 1052 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 907 member call = ???*0*["toLowerCase"]() +0 -> 1053 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 908 conditional = (???*0* === "where") +0 -> 1054 conditional = (???*0* === "where") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3175,39 +3754,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -908 -> 910 member call = ???*0*["substr"](???*1*, 5) +1054 -> 1056 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -908 -> 911 conditional = ((0 | ???*0*) === 0) +1054 -> 1057 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -911 -> 912 call = (...) => (undefined | FreeVar(undefined))( +1057 -> 1058 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "WHERE", "ignoreCase": true} ) -0 -> 913 conditional = ???*0* +0 -> 1059 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -913 -> 914 call = (...) => s0() +1059 -> 1060 call = (...) => s0() -0 -> 917 member call = ???*0*["substr"](???*1*, 5) +0 -> 1061 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1064 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 918 member call = ???*0*["toLowerCase"]() +0 -> 1065 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 919 conditional = (???*0* === "order") +0 -> 1066 conditional = (???*0* === "order") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3217,39 +3800,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -919 -> 921 member call = ???*0*["substr"](???*1*, 5) +1066 -> 1068 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -919 -> 922 conditional = ((0 | ???*0*) === 0) +1066 -> 1069 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -922 -> 923 call = (...) => (undefined | FreeVar(undefined))( +1069 -> 1070 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "ORDER", "ignoreCase": true} ) -0 -> 924 conditional = ???*0* +0 -> 1071 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -924 -> 925 call = (...) => s0() +1071 -> 1072 call = (...) => s0() -0 -> 928 member call = ???*0*["substr"](???*1*, 2) +0 -> 1073 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1076 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 929 member call = ???*0*["toLowerCase"]() +0 -> 1077 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 930 conditional = (???*0* === "by") +0 -> 1078 conditional = (???*0* === "by") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3259,39 +3846,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -930 -> 932 member call = ???*0*["substr"](???*1*, 2) +1078 -> 1080 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -930 -> 933 conditional = ((0 | ???*0*) === 0) +1078 -> 1081 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -933 -> 934 call = (...) => (undefined | FreeVar(undefined))( +1081 -> 1082 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "BY", "ignoreCase": true} ) -0 -> 935 conditional = ???*0* +0 -> 1083 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -935 -> 936 call = (...) => s0() +1083 -> 1084 call = (...) => s0() + +0 -> 1085 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 939 member call = ???*0*["substr"](???*1*, 2) +0 -> 1088 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 940 member call = ???*0*["toLowerCase"]() +0 -> 1089 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 941 conditional = (???*0* === "as") +0 -> 1090 conditional = (???*0* === "as") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3301,39 +3892,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -941 -> 943 member call = ???*0*["substr"](???*1*, 2) +1090 -> 1092 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -941 -> 944 conditional = ((0 | ???*0*) === 0) +1090 -> 1093 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -944 -> 945 call = (...) => (undefined | FreeVar(undefined))( +1093 -> 1094 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "AS", "ignoreCase": true} ) -0 -> 946 conditional = ???*0* +0 -> 1095 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -946 -> 947 call = (...) => s0() +1095 -> 1096 call = (...) => s0() -0 -> 950 member call = ???*0*["substr"](???*1*, 4) +0 -> 1097 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1100 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 951 member call = ???*0*["toLowerCase"]() +0 -> 1101 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 952 conditional = (???*0* === "join") +0 -> 1102 conditional = (???*0* === "join") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3343,39 +3938,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -952 -> 954 member call = ???*0*["substr"](???*1*, 4) +1102 -> 1104 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -952 -> 955 conditional = ((0 | ???*0*) === 0) +1102 -> 1105 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -955 -> 956 call = (...) => (undefined | FreeVar(undefined))( +1105 -> 1106 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "JOIN", "ignoreCase": true} ) -0 -> 957 conditional = ???*0* +0 -> 1107 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -957 -> 958 call = (...) => s0() +1107 -> 1108 call = (...) => s0() + +0 -> 1109 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 961 member call = ???*0*["substr"](???*1*, 2) +0 -> 1112 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 962 member call = ???*0*["toLowerCase"]() +0 -> 1113 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 963 conditional = (???*0* === "in") +0 -> 1114 conditional = (???*0* === "in") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3385,39 +3984,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -963 -> 965 member call = ???*0*["substr"](???*1*, 2) +1114 -> 1116 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -963 -> 966 conditional = ((0 | ???*0*) === 0) +1114 -> 1117 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -966 -> 967 call = (...) => (undefined | FreeVar(undefined))( +1117 -> 1118 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "IN", "ignoreCase": true} ) -0 -> 968 conditional = ???*0* +0 -> 1119 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -968 -> 969 call = (...) => s0() +1119 -> 1120 call = (...) => s0() + +0 -> 1121 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 972 member call = ???*0*["substr"](???*1*, 5) +0 -> 1124 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 973 member call = ???*0*["toLowerCase"]() +0 -> 1125 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 974 conditional = (???*0* === "value") +0 -> 1126 conditional = (???*0* === "value") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3427,39 +4030,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -974 -> 976 member call = ???*0*["substr"](???*1*, 5) +1126 -> 1128 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -974 -> 977 conditional = ((0 | ???*0*) === 0) +1126 -> 1129 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -977 -> 978 call = (...) => (undefined | FreeVar(undefined))( +1129 -> 1130 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "VALUE", "ignoreCase": true} ) -0 -> 979 conditional = ???*0* +0 -> 1131 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -979 -> 980 call = (...) => s0() +1131 -> 1132 call = (...) => s0() -0 -> 983 member call = ???*0*["substr"](???*1*, 3) +0 -> 1133 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1136 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 984 member call = ???*0*["toLowerCase"]() +0 -> 1137 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 985 conditional = (???*0* === "asc") +0 -> 1138 conditional = (???*0* === "asc") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3469,21 +4076,21 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -985 -> 987 member call = ???*0*["substr"](???*1*, 3) +1138 -> 1140 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -985 -> 988 conditional = ((0 | ???*0*) === 0) +1138 -> 1141 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -988 -> 989 call = (...) => (undefined | FreeVar(undefined))( +1141 -> 1142 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "ASC", "ignoreCase": true} ) -0 -> 990 conditional = ((???*0* | ???*1* | {} | "ASC") !== {}) +0 -> 1143 conditional = ((???*0* | ???*1* | {} | "ASC") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 3) @@ -3491,27 +4098,31 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -990 -> 991 call = (...) => s0() +1143 -> 1144 call = (...) => s0() -990 -> 992 conditional = ???*0* +1143 -> 1145 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -992 -> 993 call = (...) => "ASC"() +1145 -> 1146 call = (...) => "ASC"() + +0 -> 1147 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 996 member call = ???*0*["substr"](???*1*, 4) +0 -> 1150 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 997 member call = ???*0*["toLowerCase"]() +0 -> 1151 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 998 conditional = (???*0* === "desc") +0 -> 1152 conditional = (???*0* === "desc") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3521,21 +4132,21 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -998 -> 1000 member call = ???*0*["substr"](???*1*, 4) +1152 -> 1154 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -998 -> 1001 conditional = ((0 | ???*0*) === 0) +1152 -> 1155 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1001 -> 1002 call = (...) => (undefined | FreeVar(undefined))( +1155 -> 1156 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "DESC", "ignoreCase": true} ) -0 -> 1003 conditional = ((???*0* | ???*1* | {} | "DESC") !== {}) +0 -> 1157 conditional = ((???*0* | ???*1* | {} | "DESC") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 4) @@ -3543,27 +4154,31 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1003 -> 1004 call = (...) => s0() +1157 -> 1158 call = (...) => s0() -1003 -> 1005 conditional = ???*0* +1157 -> 1159 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1005 -> 1006 call = (...) => "DESC"() +1159 -> 1160 call = (...) => "DESC"() -0 -> 1009 member call = ???*0*["substr"](???*1*, 3) +0 -> 1161 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1164 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1010 member call = ???*0*["toLowerCase"]() +0 -> 1165 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1011 conditional = (???*0* === "and") +0 -> 1166 conditional = (???*0* === "and") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3573,21 +4188,21 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1011 -> 1013 member call = ???*0*["substr"](???*1*, 3) +1166 -> 1168 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1011 -> 1014 conditional = ((0 | ???*0*) === 0) +1166 -> 1169 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1014 -> 1015 call = (...) => (undefined | FreeVar(undefined))( +1169 -> 1170 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "AND", "ignoreCase": true} ) -0 -> 1016 conditional = ((???*0* | ???*1* | {} | "AND") !== {}) +0 -> 1171 conditional = ((???*0* | ???*1* | {} | "AND") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 3) @@ -3595,27 +4210,31 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1016 -> 1017 call = (...) => s0() +1171 -> 1172 call = (...) => s0() -1016 -> 1018 conditional = ???*0* +1171 -> 1173 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1018 -> 1019 call = (...) => "AND"() +1173 -> 1174 call = (...) => "AND"() -0 -> 1022 member call = ???*0*["substr"](???*1*, 2) +0 -> 1175 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1178 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1023 member call = ???*0*["toLowerCase"]() +0 -> 1179 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1024 conditional = (???*0* === "or") +0 -> 1180 conditional = (???*0* === "or") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3625,21 +4244,21 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1024 -> 1026 member call = ???*0*["substr"](???*1*, 2) +1180 -> 1182 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1024 -> 1027 conditional = ((0 | ???*0*) === 0) +1180 -> 1183 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1027 -> 1028 call = (...) => (undefined | FreeVar(undefined))( +1183 -> 1184 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "OR", "ignoreCase": true} ) -0 -> 1029 conditional = ((???*0* | ???*1* | {} | "OR") !== {}) +0 -> 1185 conditional = ((???*0* | ???*1* | {} | "OR") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 2) @@ -3647,27 +4266,31 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1029 -> 1030 call = (...) => s0() +1185 -> 1186 call = (...) => s0() -1029 -> 1031 conditional = ???*0* +1185 -> 1187 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1031 -> 1032 call = (...) => "OR"() +1187 -> 1188 call = (...) => "OR"() + +0 -> 1189 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1035 member call = ???*0*["substr"](???*1*, 3) +0 -> 1192 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1036 member call = ???*0*["toLowerCase"]() +0 -> 1193 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1037 conditional = (???*0* === "not") +0 -> 1194 conditional = (???*0* === "not") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3677,21 +4300,21 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1037 -> 1039 member call = ???*0*["substr"](???*1*, 3) +1194 -> 1196 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1037 -> 1040 conditional = ((0 | ???*0*) === 0) +1194 -> 1197 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1040 -> 1041 call = (...) => (undefined | FreeVar(undefined))( +1197 -> 1198 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "NOT", "ignoreCase": true} ) -0 -> 1042 conditional = ((???*0* | ???*1* | {} | "NOT") !== {}) +0 -> 1199 conditional = ((???*0* | ???*1* | {} | "NOT") !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substr"](peg$currPos, 3) @@ -3699,27 +4322,31 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1042 -> 1043 call = (...) => s0() +1199 -> 1200 call = (...) => s0() -1042 -> 1044 conditional = ???*0* +1199 -> 1201 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1044 -> 1045 call = (...) => "NOT"() +1201 -> 1202 call = (...) => "NOT"() -0 -> 1048 member call = ???*0*["substr"](???*1*, 7) +0 -> 1203 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1206 member call = ???*0*["substr"](???*1*, 7) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1049 member call = ???*0*["toLowerCase"]() +0 -> 1207 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 7) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1050 conditional = (???*0* === "between") +0 -> 1208 conditional = (???*0* === "between") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3729,39 +4356,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1050 -> 1052 member call = ???*0*["substr"](???*1*, 7) +1208 -> 1210 member call = ???*0*["substr"](???*1*, 7) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1050 -> 1053 conditional = ((0 | ???*0*) === 0) +1208 -> 1211 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1053 -> 1054 call = (...) => (undefined | FreeVar(undefined))( +1211 -> 1212 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "BETWEEN", "ignoreCase": true} ) -0 -> 1055 conditional = ???*0* +0 -> 1213 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1055 -> 1056 call = (...) => s0() +1213 -> 1214 call = (...) => s0() + +0 -> 1215 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1059 member call = ???*0*["substr"](???*1*, 6) +0 -> 1218 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1060 member call = ???*0*["toLowerCase"]() +0 -> 1219 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 6) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1061 conditional = (???*0* === "exists") +0 -> 1220 conditional = (???*0* === "exists") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3771,39 +4402,43 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1061 -> 1063 member call = ???*0*["substr"](???*1*, 6) +1220 -> 1222 member call = ???*0*["substr"](???*1*, 6) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1061 -> 1064 conditional = ((0 | ???*0*) === 0) +1220 -> 1223 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1064 -> 1065 call = (...) => (undefined | FreeVar(undefined))( +1223 -> 1224 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "EXISTS", "ignoreCase": true} ) -0 -> 1066 conditional = ???*0* +0 -> 1225 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1066 -> 1067 call = (...) => s0() +1225 -> 1226 call = (...) => s0() + +0 -> 1227 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1070 member call = ???*0*["substr"](???*1*, 5) +0 -> 1230 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1071 member call = ???*0*["toLowerCase"]() +0 -> 1231 member call = ???*0*["toLowerCase"]() - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1072 conditional = (???*0* === "array") +0 -> 1232 conditional = (???*0* === "array") - *0* ???*1*() ⚠️ nested operation - *1* ???*2*["toLowerCase"] @@ -3813,309 +4448,341 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1072 -> 1074 member call = ???*0*["substr"](???*1*, 5) +1232 -> 1234 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1072 -> 1075 conditional = ((0 | ???*0*) === 0) +1232 -> 1235 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1075 -> 1076 call = (...) => (undefined | FreeVar(undefined))( +1235 -> 1236 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "ARRAY", "ignoreCase": true} ) -0 -> 1077 conditional = ???*0* +0 -> 1237 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1077 -> 1078 call = (...) => s0() +1237 -> 1238 call = (...) => s0() + +0 -> 1239 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1080 member call = ???*0*["substr"](???*1*, 4) +0 -> 1241 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1081 conditional = (???*0* === "null") +0 -> 1242 conditional = (???*0* === "null") - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1081 -> 1082 conditional = ((0 | ???*0*) === 0) +1242 -> 1243 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1082 -> 1083 call = (...) => (undefined | FreeVar(undefined))( +1243 -> 1244 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "null", "ignoreCase": false} ) -0 -> 1084 conditional = ???*0* +0 -> 1245 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1084 -> 1085 call = (...) => s0() +1245 -> 1246 call = (...) => s0() + +0 -> 1247 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1087 member call = ???*0*["substr"](???*1*, 4) +0 -> 1249 member call = ???*0*["substr"](???*1*, 4) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1088 conditional = (???*0* === "true") +0 -> 1250 conditional = (???*0* === "true") - *0* ???*1*["substr"](peg$currPos, 4) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1088 -> 1089 conditional = ((0 | ???*0*) === 0) +1250 -> 1251 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1089 -> 1090 call = (...) => (undefined | FreeVar(undefined))( +1251 -> 1252 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "true", "ignoreCase": false} ) -0 -> 1091 conditional = ???*0* +0 -> 1253 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1091 -> 1092 call = (...) => s0() +1253 -> 1254 call = (...) => s0() + +0 -> 1255 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1094 member call = ???*0*["substr"](???*1*, 5) +0 -> 1257 member call = ???*0*["substr"](???*1*, 5) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1095 conditional = (???*0* === "false") +0 -> 1258 conditional = (???*0* === "false") - *0* ???*1*["substr"](peg$currPos, 5) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1095 -> 1096 conditional = ((0 | ???*0*) === 0) +1258 -> 1259 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1096 -> 1097 call = (...) => (undefined | FreeVar(undefined))( +1259 -> 1260 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "false", "ignoreCase": false} ) -0 -> 1098 conditional = ???*0* +0 -> 1261 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1098 -> 1099 call = (...) => s0() +1261 -> 1262 call = (...) => s0() + +0 -> 1263 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1101 member call = ???*0*["substr"](???*1*, 3) +0 -> 1265 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1102 conditional = (???*0* === "udf") +0 -> 1266 conditional = (???*0* === "udf") - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1102 -> 1103 conditional = ((0 | ???*0*) === 0) +1266 -> 1267 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1103 -> 1104 call = (...) => (undefined | FreeVar(undefined))( +1267 -> 1268 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "udf", "ignoreCase": false} ) -0 -> 1105 conditional = ???*0* +0 -> 1269 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1105 -> 1106 call = (...) => s0() +1269 -> 1270 call = (...) => s0() + +0 -> 1271 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1107 call = (...) => s0() +0 -> 1272 call = (...) => s0() -0 -> 1108 conditional = ???*0* +0 -> 1273 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1108 -> 1109 call = (...) => s0() +1273 -> 1274 call = (...) => s0() -1108 -> 1110 conditional = ???*0* +1273 -> 1275 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1110 -> 1111 call = (...) => s0() +1275 -> 1276 call = (...) => s0() -1110 -> 1112 conditional = ???*0* +1275 -> 1277 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1112 -> 1113 call = (...) => s0() +1277 -> 1278 call = (...) => s0() -1112 -> 1114 conditional = ???*0* +1277 -> 1279 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1114 -> 1115 call = (...) => s0() +1279 -> 1280 call = (...) => s0() -1114 -> 1116 conditional = ???*0* +1279 -> 1281 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1116 -> 1117 call = (...) => s0() +1281 -> 1282 call = (...) => s0() -1116 -> 1118 conditional = ???*0* +1281 -> 1283 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1118 -> 1119 call = (...) => s0() +1283 -> 1284 call = (...) => s0() -1118 -> 1120 conditional = ???*0* +1283 -> 1285 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1120 -> 1121 call = (...) => s0() +1285 -> 1286 call = (...) => s0() -1120 -> 1122 conditional = ???*0* +1285 -> 1287 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1122 -> 1123 call = (...) => s0() +1287 -> 1288 call = (...) => s0() -1122 -> 1124 conditional = ???*0* +1287 -> 1289 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1124 -> 1125 call = (...) => s0() +1289 -> 1290 call = (...) => s0() -1124 -> 1126 conditional = ???*0* +1289 -> 1291 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1126 -> 1127 call = (...) => s0() +1291 -> 1292 call = (...) => s0() -1126 -> 1128 conditional = ???*0* +1291 -> 1293 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1128 -> 1129 call = (...) => s0() +1293 -> 1294 call = (...) => s0() -1128 -> 1130 conditional = ???*0* +1293 -> 1295 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1130 -> 1131 call = (...) => s0() +1295 -> 1296 call = (...) => s0() -1130 -> 1132 conditional = ???*0* +1295 -> 1297 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1132 -> 1133 call = (...) => s0() +1297 -> 1298 call = (...) => s0() -1132 -> 1134 conditional = ???*0* +1297 -> 1299 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1134 -> 1135 call = (...) => s0() +1299 -> 1300 call = (...) => s0() -1134 -> 1136 conditional = ???*0* +1299 -> 1301 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1136 -> 1137 call = (...) => s0() +1301 -> 1302 call = (...) => s0() -1136 -> 1138 conditional = ???*0* +1301 -> 1303 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1138 -> 1139 call = (...) => s0() +1303 -> 1304 call = (...) => s0() -1138 -> 1140 conditional = ???*0* +1303 -> 1305 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1140 -> 1141 call = (...) => s0() +1305 -> 1306 call = (...) => s0() -1140 -> 1142 conditional = ???*0* +1305 -> 1307 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1142 -> 1143 call = (...) => s0() +1307 -> 1308 call = (...) => s0() -1142 -> 1144 conditional = ???*0* +1307 -> 1309 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1144 -> 1145 call = (...) => s0() +1309 -> 1310 call = (...) => s0() -1144 -> 1146 conditional = ???*0* +1309 -> 1311 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1146 -> 1147 call = (...) => s0() +1311 -> 1312 call = (...) => s0() -1146 -> 1148 conditional = ???*0* +1311 -> 1313 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1148 -> 1149 call = (...) => s0() +1313 -> 1314 call = (...) => s0() -0 -> 1150 call = (...) => s0() +0 -> 1315 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1316 call = (...) => s0() -0 -> 1151 conditional = ???*0* +0 -> 1317 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1151 -> 1152 call = (...) => s0() +1317 -> 1318 call = (...) => s0() -1151 -> 1153 conditional = ???*0* +1317 -> 1319 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1153 -> 1154 call = (...) => {"type": "identifier", "name": name}(???*0*) +1319 -> 1320 call = (...) => {"type": "identifier", "name": name}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1157 member call = ???*0*["charAt"](???*1*) +0 -> 1321 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1324 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1158 member call = /^[a-zA-Z_]/["test"](???*0*) +0 -> 1325 member call = /^[a-zA-Z_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1159 conditional = /^[a-zA-Z_]/["test"](???*0*) +0 -> 1326 conditional = /^[a-zA-Z_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1159 -> 1161 member call = ???*0*["charAt"](???*1*) +1326 -> 1328 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1159 -> 1162 conditional = ((0 | ???*0*) === 0) +1326 -> 1329 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1162 -> 1163 call = (...) => (undefined | FreeVar(undefined))( +1329 -> 1330 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["a", "z"], ["A", "Z"], "_"], "inverted": false, "ignoreCase": false} ) -0 -> 1164 call = (...) => s0() +0 -> 1331 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1332 call = (...) => s0() -0 -> 1165 conditional = ((???*0* | ???*1* | {} | ???*3*) !== {}) +0 -> 1333 conditional = ((???*0* | ???*1* | {} | ???*3*) !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -4135,35 +4802,35 @@ - *8* []["join"] ⚠️ non-num constant property on array -1165 -> 1168 member call = ???*0*["charAt"](???*1*) +1333 -> 1336 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1165 -> 1169 member call = /^[a-zA-Z0-9_]/["test"](???*0*) +1333 -> 1337 member call = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1165 -> 1170 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) +1333 -> 1338 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1170 -> 1172 member call = ???*0*["charAt"](???*1*) +1338 -> 1340 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1170 -> 1173 conditional = ((0 | ???*0*) === 0) +1338 -> 1341 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1173 -> 1174 call = (...) => (undefined | FreeVar(undefined))( +1341 -> 1342 call = (...) => (undefined | FreeVar(undefined))( { "type": "class", "parts": [["a", "z"], ["A", "Z"], ["0", "9"], "_"], @@ -4172,7 +4839,7 @@ } ) -1165 -> 1176 member call = (???*0* | [])["push"]((???*1* | ???*2* | {})) +1333 -> 1344 member call = (???*0* | [])["push"]((???*1* | ???*2* | {})) - *0* s2 ⚠️ pattern without value - *1* s3 @@ -4182,35 +4849,35 @@ - *3* arguments[0] ⚠️ function calls are not analysed yet -1165 -> 1179 member call = ???*0*["charAt"](???*1*) +1333 -> 1347 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1165 -> 1180 member call = /^[a-zA-Z0-9_]/["test"](???*0*) +1333 -> 1348 member call = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1165 -> 1181 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) +1333 -> 1349 conditional = /^[a-zA-Z0-9_]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1181 -> 1183 member call = ???*0*["charAt"](???*1*) +1349 -> 1351 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1181 -> 1184 conditional = ((0 | ???*0*) === 0) +1349 -> 1352 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1184 -> 1185 call = (...) => (undefined | FreeVar(undefined))( +1352 -> 1353 call = (...) => (undefined | FreeVar(undefined))( { "type": "class", "parts": [["a", "z"], ["A", "Z"], ["0", "9"], "_"], @@ -4219,11 +4886,11 @@ } ) -1165 -> 1186 conditional = ((???*0* | []) !== {}) +1333 -> 1354 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1186 -> 1187 call = (...) => (head + tail["join"](""))( +1354 -> 1355 call = (...) => (head + tail["join"](""))( (???*0* | ???*1* | {} | (???*3* + (???*4* | ???*6*))), (???*8* | []) ) @@ -4246,27 +4913,31 @@ - *8* s2 ⚠️ pattern without value -0 -> 1189 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1356 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1358 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1190 conditional = (???*0* === 64) +0 -> 1359 conditional = (???*0* === 64) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1190 -> 1191 conditional = ((0 | ???*0*) === 0) +1359 -> 1360 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1191 -> 1192 call = (...) => (undefined | FreeVar(undefined))( +1360 -> 1361 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "@", "ignoreCase": false} ) -0 -> 1193 conditional = ((???*0* | "@" | {} | {"type": "parameter_name", "name": ???*1*}) !== {}) +0 -> 1362 conditional = ((???*0* | "@" | {} | {"type": "parameter_name", "name": ???*1*}) !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*["substring"](peg$savedPos, peg$currPos) @@ -4274,589 +4945,629 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1193 -> 1194 call = (...) => s0() +1362 -> 1363 call = (...) => s0() -1193 -> 1195 conditional = ???*0* +1362 -> 1364 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1195 -> 1196 call = (...) => {"type": "parameter_name", "name": text()}() +1364 -> 1365 call = (...) => {"type": "parameter_name", "name": text()}() -0 -> 1198 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1366 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1368 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1199 conditional = (???*0* === 43) +0 -> 1369 conditional = (???*0* === 43) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1199 -> 1200 conditional = ((0 | ???*0*) === 0) +1369 -> 1370 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1200 -> 1201 call = (...) => (undefined | FreeVar(undefined))( +1370 -> 1371 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "+", "ignoreCase": false} ) -0 -> 1202 conditional = ???*0* +0 -> 1372 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1202 -> 1204 member call = ???*0*["charCodeAt"](???*1*) +1372 -> 1374 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1202 -> 1205 conditional = (???*0* === 45) +1372 -> 1375 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1205 -> 1206 conditional = ((0 | ???*0*) === 0) +1375 -> 1376 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1206 -> 1207 call = (...) => (undefined | FreeVar(undefined))( +1376 -> 1377 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "-", "ignoreCase": false} ) -1202 -> 1208 conditional = ???*0* +1372 -> 1378 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1208 -> 1210 member call = ???*0*["charCodeAt"](???*1*) +1378 -> 1380 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1208 -> 1211 conditional = (???*0* === 126) +1378 -> 1381 conditional = (???*0* === 126) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1211 -> 1212 conditional = ((0 | ???*0*) === 0) +1381 -> 1382 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1212 -> 1213 call = (...) => (undefined | FreeVar(undefined))( +1382 -> 1383 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "~", "ignoreCase": false} ) -1208 -> 1214 conditional = ???*0* +1378 -> 1384 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1214 -> 1215 call = (...) => s0() +1384 -> 1385 call = (...) => s0() + +0 -> 1386 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1217 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1388 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1218 conditional = (???*0* === 34) +0 -> 1389 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1218 -> 1219 conditional = ((0 | ???*0*) === 0) +1389 -> 1390 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1219 -> 1220 call = (...) => (undefined | FreeVar(undefined))( +1390 -> 1391 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\"", "ignoreCase": false} ) -0 -> 1221 conditional = ???*0* +0 -> 1392 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1221 -> 1223 member call = ???*0*["charCodeAt"](???*1*) +1392 -> 1394 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1221 -> 1224 conditional = (???*0* === 92) +1392 -> 1395 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1224 -> 1225 conditional = ((0 | ???*0*) === 0) +1395 -> 1396 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1225 -> 1226 call = (...) => (undefined | FreeVar(undefined))( +1396 -> 1397 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\\", "ignoreCase": false} ) -0 -> 1227 conditional = ???*0* +0 -> 1398 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1227 -> 1228 call = (...) => s0() +1398 -> 1399 call = (...) => s0() -1227 -> 1229 conditional = ???*0* +1398 -> 1400 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1229 -> 1230 call = (...) => text()() +1400 -> 1401 call = (...) => text()() -0 -> 1231 conditional = ???*0* +0 -> 1402 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1231 -> 1233 member call = ???*0*["charCodeAt"](???*1*) +1402 -> 1404 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1231 -> 1234 conditional = (???*0* === 92) +1402 -> 1405 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1234 -> 1235 conditional = ((0 | ???*0*) === 0) +1405 -> 1406 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1235 -> 1236 call = (...) => (undefined | FreeVar(undefined))( +1406 -> 1407 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\\", "ignoreCase": false} ) -1231 -> 1237 conditional = ???*0* +1402 -> 1408 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1237 -> 1238 call = (...) => s0() +1408 -> 1409 call = (...) => s0() -1237 -> 1239 conditional = ???*0* +1408 -> 1410 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1239 -> 1240 call = (...) => seq(???*0*) +1410 -> 1411 call = (...) => seq(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1242 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1412 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1414 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1243 conditional = (???*0* === 39) +0 -> 1415 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1243 -> 1244 conditional = ((0 | ???*0*) === 0) +1415 -> 1416 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1244 -> 1245 call = (...) => (undefined | FreeVar(undefined))( +1416 -> 1417 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "'", "ignoreCase": false} ) -0 -> 1246 conditional = ???*0* +0 -> 1418 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1246 -> 1248 member call = ???*0*["charCodeAt"](???*1*) +1418 -> 1420 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1246 -> 1249 conditional = (???*0* === 92) +1418 -> 1421 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1249 -> 1250 conditional = ((0 | ???*0*) === 0) +1421 -> 1422 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1250 -> 1251 call = (...) => (undefined | FreeVar(undefined))( +1422 -> 1423 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\\", "ignoreCase": false} ) -0 -> 1252 conditional = ???*0* +0 -> 1424 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1252 -> 1253 call = (...) => s0() +1424 -> 1425 call = (...) => s0() -1252 -> 1254 conditional = ???*0* +1424 -> 1426 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1254 -> 1255 call = (...) => text()() +1426 -> 1427 call = (...) => text()() -0 -> 1256 conditional = ???*0* +0 -> 1428 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1256 -> 1258 member call = ???*0*["charCodeAt"](???*1*) +1428 -> 1430 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1256 -> 1259 conditional = (???*0* === 92) +1428 -> 1431 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1259 -> 1260 conditional = ((0 | ???*0*) === 0) +1431 -> 1432 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1260 -> 1261 call = (...) => (undefined | FreeVar(undefined))( +1432 -> 1433 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\\", "ignoreCase": false} ) -1256 -> 1262 conditional = ???*0* +1428 -> 1434 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1262 -> 1263 call = (...) => s0() +1434 -> 1435 call = (...) => s0() -1262 -> 1264 conditional = ???*0* +1434 -> 1436 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1264 -> 1265 call = (...) => seq(???*0*) +1436 -> 1437 call = (...) => seq(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1268 member call = ???*0*["charAt"](???*1*) +0 -> 1438 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1441 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1269 conditional = ((0 | ???*0*) === 0) +0 -> 1442 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1269 -> 1270 call = (...) => (undefined | FreeVar(undefined))({"type": "any"}) +1442 -> 1443 call = (...) => (undefined | FreeVar(undefined))({"type": "any"}) + +0 -> 1444 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1271 call = (...) => s0() +0 -> 1445 call = (...) => s0() -0 -> 1272 conditional = ???*0* +0 -> 1446 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1272 -> 1273 call = (...) => s0() +1446 -> 1447 call = (...) => s0() + +0 -> 1448 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1274 call = (...) => s0() +0 -> 1449 call = (...) => s0() -0 -> 1275 conditional = ???*0* +0 -> 1450 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1275 -> 1276 call = (...) => s0() +1450 -> 1451 call = (...) => s0() + +0 -> 1452 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1278 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1454 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1279 conditional = (???*0* === 39) +0 -> 1455 conditional = (???*0* === 39) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1279 -> 1280 conditional = ((0 | ???*0*) === 0) +1455 -> 1456 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1280 -> 1281 call = (...) => (undefined | FreeVar(undefined))( +1456 -> 1457 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "'", "ignoreCase": false} ) -0 -> 1282 conditional = ???*0* +0 -> 1458 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1282 -> 1284 member call = ???*0*["charCodeAt"](???*1*) +1458 -> 1460 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1282 -> 1285 conditional = (???*0* === 34) +1458 -> 1461 conditional = (???*0* === 34) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1285 -> 1286 conditional = ((0 | ???*0*) === 0) +1461 -> 1462 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1286 -> 1287 call = (...) => (undefined | FreeVar(undefined))( +1462 -> 1463 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\"", "ignoreCase": false} ) -1282 -> 1288 conditional = ???*0* +1458 -> 1464 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1288 -> 1290 member call = ???*0*["charCodeAt"](???*1*) +1464 -> 1466 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1288 -> 1291 conditional = (???*0* === 92) +1464 -> 1467 conditional = (???*0* === 92) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1291 -> 1292 conditional = ((0 | ???*0*) === 0) +1467 -> 1468 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1292 -> 1293 call = (...) => (undefined | FreeVar(undefined))( +1468 -> 1469 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "\\", "ignoreCase": false} ) -1288 -> 1294 conditional = ???*0* +1464 -> 1470 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1294 -> 1296 member call = ???*0*["charCodeAt"](???*1*) +1470 -> 1472 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1294 -> 1297 conditional = (???*0* === 98) +1470 -> 1473 conditional = (???*0* === 98) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1297 -> 1298 conditional = ((0 | ???*0*) === 0) +1473 -> 1474 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1298 -> 1299 call = (...) => (undefined | FreeVar(undefined))( +1474 -> 1475 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "b", "ignoreCase": false} ) -1294 -> 1300 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1470 -> 1476 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1300 -> 1301 call = (...) => "\b"() +1476 -> 1477 call = (...) => "\b"() -1294 -> 1302 conditional = ???*0* +1470 -> 1478 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1302 -> 1304 member call = ???*0*["charCodeAt"](???*1*) +1478 -> 1480 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1302 -> 1305 conditional = (???*0* === 102) +1478 -> 1481 conditional = (???*0* === 102) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1305 -> 1306 conditional = ((0 | ???*0*) === 0) +1481 -> 1482 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1306 -> 1307 call = (...) => (undefined | FreeVar(undefined))( +1482 -> 1483 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "f", "ignoreCase": false} ) -1302 -> 1308 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1478 -> 1484 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1308 -> 1309 call = (...) => "\f"() +1484 -> 1485 call = (...) => "\f"() -1302 -> 1310 conditional = ???*0* +1478 -> 1486 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1310 -> 1312 member call = ???*0*["charCodeAt"](???*1*) +1486 -> 1488 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1310 -> 1313 conditional = (???*0* === 110) +1486 -> 1489 conditional = (???*0* === 110) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1313 -> 1314 conditional = ((0 | ???*0*) === 0) +1489 -> 1490 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1314 -> 1315 call = (...) => (undefined | FreeVar(undefined))( +1490 -> 1491 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "n", "ignoreCase": false} ) -1310 -> 1316 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1486 -> 1492 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1316 -> 1317 call = (...) => "\n"() +1492 -> 1493 call = (...) => "\n"() -1310 -> 1318 conditional = ???*0* +1486 -> 1494 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1318 -> 1320 member call = ???*0*["charCodeAt"](???*1*) +1494 -> 1496 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1318 -> 1321 conditional = (???*0* === 114) +1494 -> 1497 conditional = (???*0* === 114) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1321 -> 1322 conditional = ((0 | ???*0*) === 0) +1497 -> 1498 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1322 -> 1323 call = (...) => (undefined | FreeVar(undefined))( +1498 -> 1499 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "r", "ignoreCase": false} ) -1318 -> 1324 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1494 -> 1500 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1324 -> 1325 call = (...) => "\r"() +1500 -> 1501 call = (...) => "\r"() -1318 -> 1326 conditional = ???*0* +1494 -> 1502 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1326 -> 1328 member call = ???*0*["charCodeAt"](???*1*) +1502 -> 1504 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1326 -> 1329 conditional = (???*0* === 116) +1502 -> 1505 conditional = (???*0* === 116) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1329 -> 1330 conditional = ((0 | ???*0*) === 0) +1505 -> 1506 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1330 -> 1331 call = (...) => (undefined | FreeVar(undefined))( +1506 -> 1507 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "t", "ignoreCase": false} ) -1326 -> 1332 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) +1502 -> 1508 conditional = ((???*0* | "b" | {} | "\b" | "f" | "\f" | "n" | "\n" | "r" | "\r" | "t" | "\t") !== {}) - *0* s1 ⚠️ pattern without value -1332 -> 1333 call = (...) => "\t"() +1508 -> 1509 call = (...) => "\t"() + +0 -> 1510 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1334 call = (...) => s0() +0 -> 1511 call = (...) => s0() -0 -> 1335 conditional = ???*0* +0 -> 1512 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1335 -> 1336 call = (...) => s0() +1512 -> 1513 call = (...) => s0() -1335 -> 1337 conditional = ???*0* +1512 -> 1514 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1337 -> 1338 call = (...) => text()() +1514 -> 1515 call = (...) => text()() -0 -> 1339 call = (...) => s0() +0 -> 1516 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1517 call = (...) => s0() -0 -> 1340 conditional = ???*0* +0 -> 1518 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1340 -> 1342 member call = ???*0*["charCodeAt"](???*1*) +1518 -> 1520 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1340 -> 1343 conditional = (???*0* === 117) +1518 -> 1521 conditional = (???*0* === 117) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1343 -> 1344 conditional = ((0 | ???*0*) === 0) +1521 -> 1522 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1344 -> 1345 call = (...) => (undefined | FreeVar(undefined))( +1522 -> 1523 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "u", "ignoreCase": false} ) -0 -> 1347 member call = ???*0*["charCodeAt"](???*1*) +0 -> 1524 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1526 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1348 conditional = (???*0* === 117) +0 -> 1527 conditional = (???*0* === 117) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1348 -> 1349 conditional = ((0 | ???*0*) === 0) +1527 -> 1528 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1349 -> 1350 call = (...) => (undefined | FreeVar(undefined))( +1528 -> 1529 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "u", "ignoreCase": false} ) -0 -> 1351 conditional = ???*0* +0 -> 1530 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1351 -> 1352 call = (...) => s0() +1530 -> 1531 call = (...) => s0() -1351 -> 1353 conditional = (( +1530 -> 1532 conditional = (( | ???*0* | ???*1* | {} @@ -4889,9 +5600,9 @@ - *12* arguments[0] ⚠️ function calls are not analysed yet -1353 -> 1354 call = (...) => s0() +1532 -> 1533 call = (...) => s0() -1353 -> 1355 conditional = ((???*0* | ???*1* | {}) !== {}) +1532 -> 1534 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s5 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -4899,9 +5610,9 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1355 -> 1356 call = (...) => s0() +1534 -> 1535 call = (...) => s0() -1355 -> 1357 conditional = ((???*0* | ???*1* | {}) !== {}) +1534 -> 1536 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s6 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -4909,13 +5620,13 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -1357 -> 1358 call = (...) => s0() +1536 -> 1537 call = (...) => s0() -1351 -> 1359 conditional = ???*0* +1530 -> 1538 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1359 -> 1361 member call = ???*0*["substring"](???*1*, ???*2*) +1538 -> 1540 member call = ???*0*["substring"](???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached @@ -4923,711 +5634,751 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -1351 -> 1362 conditional = ???*0* +1530 -> 1541 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1362 -> 1363 call = (...) => FreeVar(String)["fromCharCode"](FreeVar(parseInt)(digits, 16))(???*0*) +1541 -> 1542 call = (...) => FreeVar(String)["fromCharCode"](FreeVar(parseInt)(digits, 16))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1366 member call = ???*0*["charAt"](???*1*) +0 -> 1543 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1546 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1367 member call = /^[0-9a-f]/i["test"](???*0*) +0 -> 1547 member call = /^[0-9a-f]/i["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1368 conditional = /^[0-9a-f]/i["test"](???*0*) +0 -> 1548 conditional = /^[0-9a-f]/i["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1368 -> 1370 member call = ???*0*["charAt"](???*1*) +1548 -> 1550 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1368 -> 1371 conditional = ((0 | ???*0*) === 0) +1548 -> 1551 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1371 -> 1372 call = (...) => (undefined | FreeVar(undefined))( +1551 -> 1552 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"], ["a", "f"]], "inverted": false, "ignoreCase": true} ) -0 -> 1373 call = (...) => s0() +0 -> 1553 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1554 call = (...) => s0() -0 -> 1374 conditional = ???*0* +0 -> 1555 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1374 -> 1375 call = (...) => s0() +1555 -> 1556 call = (...) => s0() -1374 -> 1376 conditional = ???*0* +1555 -> 1557 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1376 -> 1377 call = (...) => s0() +1557 -> 1558 call = (...) => s0() -1374 -> 1378 conditional = ???*0* +1555 -> 1559 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1378 -> 1379 call = (...) => s0() +1559 -> 1560 call = (...) => s0() -1378 -> 1380 conditional = ???*0* +1559 -> 1561 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1380 -> 1381 call = (...) => s0() +1561 -> 1562 call = (...) => s0() -1380 -> 1382 conditional = ???*0* +1561 -> 1563 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1382 -> 1383 call = (...) => v(???*0*, ???*1*) +1563 -> 1564 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1374 -> 1384 conditional = ???*0* +1555 -> 1565 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1384 -> 1385 call = (...) => {"property": property, "alias": alias}(???*0*, ???*1*) +1565 -> 1566 call = (...) => {"property": property, "alias": alias}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1386 call = (...) => s0() +0 -> 1567 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1568 call = (...) => s0() -0 -> 1387 conditional = ???*0* +0 -> 1569 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1387 -> 1388 call = (...) => s0() +1569 -> 1570 call = (...) => s0() -1387 -> 1389 conditional = ???*0* +1569 -> 1571 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1389 -> 1390 call = (...) => s0() +1571 -> 1572 call = (...) => s0() -1389 -> 1391 conditional = ???*0* +1571 -> 1573 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1391 -> 1392 call = (...) => s0() +1573 -> 1574 call = (...) => s0() -1391 -> 1393 conditional = ???*0* +1573 -> 1575 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1393 -> 1394 call = (...) => s0() +1575 -> 1576 call = (...) => s0() -1393 -> 1395 conditional = ???*0* +1575 -> 1577 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1395 -> 1396 call = (...) => s0() +1577 -> 1578 call = (...) => s0() -1395 -> 1397 conditional = ???*0* +1577 -> 1579 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1397 -> 1399 member call = ???*0*["charCodeAt"](???*1*) +1579 -> 1581 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1397 -> 1400 conditional = (???*0* === 40) +1579 -> 1582 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1400 -> 1401 conditional = ((0 | ???*0*) === 0) +1582 -> 1583 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1401 -> 1402 call = (...) => (undefined | FreeVar(undefined))( +1583 -> 1584 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "(", "ignoreCase": false} ) -1397 -> 1403 conditional = ???*0* +1579 -> 1585 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1403 -> 1404 call = (...) => s0() +1585 -> 1586 call = (...) => s0() -1403 -> 1405 conditional = ((???*0* | []) !== {}) +1585 -> 1587 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1405 -> 1406 call = (...) => s0() +1587 -> 1588 call = (...) => s0() -1405 -> 1407 conditional = ???*0* +1587 -> 1589 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1407 -> 1408 call = (...) => s0() +1589 -> 1590 call = (...) => s0() -1407 -> 1409 conditional = ((???*0* | []) !== {}) +1589 -> 1591 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1409 -> 1411 member call = ???*0*["charCodeAt"](???*1*) +1591 -> 1593 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1409 -> 1412 conditional = (???*0* === 41) +1591 -> 1594 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1412 -> 1413 conditional = ((0 | ???*0*) === 0) +1594 -> 1595 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1413 -> 1414 call = (...) => (undefined | FreeVar(undefined))( +1595 -> 1596 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ")", "ignoreCase": false} ) -1409 -> 1415 conditional = ((???*0* | ")" | {}) !== {}) +1591 -> 1597 conditional = ((???*0* | ")" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1415 -> 1416 call = (...) => expression(???*0*) +1597 -> 1598 call = (...) => expression(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1417 call = (...) => s0() +0 -> 1599 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1600 call = (...) => s0() -0 -> 1418 conditional = ???*0* +0 -> 1601 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1418 -> 1419 call = (...) => s0() +1601 -> 1602 call = (...) => s0() -1418 -> 1420 conditional = ???*0* +1601 -> 1603 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1420 -> 1421 call = (...) => s0() +1603 -> 1604 call = (...) => s0() -0 -> 1422 call = (...) => s0() +0 -> 1605 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1606 call = (...) => s0() -0 -> 1423 conditional = ???*0* +0 -> 1607 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1423 -> 1424 call = (...) => s0() +1607 -> 1608 call = (...) => s0() -1423 -> 1425 conditional = ((???*0* | []) !== {}) +1607 -> 1609 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1425 -> 1426 call = (...) => s0() +1609 -> 1610 call = (...) => s0() -1425 -> 1427 conditional = ???*0* +1609 -> 1611 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1427 -> 1428 call = (...) => {"type": "array_subquery_expression", "expression": expression}(???*0*) +1611 -> 1612 call = (...) => {"type": "array_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1429 call = (...) => s0() +0 -> 1613 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1614 call = (...) => s0() -0 -> 1430 conditional = ???*0* +0 -> 1615 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1430 -> 1431 call = (...) => s0() +1615 -> 1616 call = (...) => s0() -1430 -> 1432 conditional = ((???*0* | []) !== {}) +1615 -> 1617 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1432 -> 1433 call = (...) => s0() +1617 -> 1618 call = (...) => s0() -1432 -> 1434 conditional = ???*0* +1617 -> 1619 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1434 -> 1435 call = (...) => {"type": "exists_subquery_expression", "expression": expression}(???*0*) +1619 -> 1620 call = (...) => {"type": "exists_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1436 call = (...) => s0() +0 -> 1621 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1622 call = (...) => s0() -0 -> 1437 conditional = ???*0* +0 -> 1623 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1437 -> 1438 call = (...) => {"type": "scalar_subquery_expression", "expression": expression}(???*0*) +1623 -> 1624 call = (...) => {"type": "scalar_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1439 call = (...) => s0() +0 -> 1625 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1626 call = (...) => s0() -0 -> 1440 conditional = ???*0* +0 -> 1627 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1440 -> 1441 call = (...) => s0() +1627 -> 1628 call = (...) => s0() -1440 -> 1442 conditional = ???*0* +1627 -> 1629 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1442 -> 1444 member call = ???*0*["charCodeAt"](???*1*) +1629 -> 1631 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1442 -> 1445 conditional = (???*0* === 46) +1629 -> 1632 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1445 -> 1446 conditional = ((0 | ???*0*) === 0) +1632 -> 1633 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1446 -> 1447 call = (...) => (undefined | FreeVar(undefined))( +1633 -> 1634 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ".", "ignoreCase": false} ) -1442 -> 1448 conditional = ((???*0* | "." | {} | "[") !== {}) +1629 -> 1635 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1448 -> 1449 call = (...) => s0() +1635 -> 1636 call = (...) => s0() -1448 -> 1450 conditional = ((???*0* | []) !== {}) +1635 -> 1637 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1450 -> 1451 call = (...) => s0() +1637 -> 1638 call = (...) => s0() -1450 -> 1452 conditional = ???*0* +1637 -> 1639 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1452 -> 1453 call = (...) => s0() +1639 -> 1640 call = (...) => s0() -1452 -> 1454 conditional = ((???*0* | []) !== {}) +1639 -> 1641 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1454 -> 1455 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +1641 -> 1642 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1440 -> 1456 conditional = ???*0* +1627 -> 1643 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1456 -> 1457 call = (...) => s0() +1643 -> 1644 call = (...) => s0() -1456 -> 1458 conditional = ???*0* +1643 -> 1645 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1458 -> 1460 member call = ???*0*["charCodeAt"](???*1*) +1645 -> 1647 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1458 -> 1461 conditional = (???*0* === 91) +1645 -> 1648 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1461 -> 1462 conditional = ((0 | ???*0*) === 0) +1648 -> 1649 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1462 -> 1463 call = (...) => (undefined | FreeVar(undefined))( +1649 -> 1650 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "[", "ignoreCase": false} ) -1458 -> 1464 conditional = ((???*0* | "." | {} | "[") !== {}) +1645 -> 1651 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1464 -> 1465 call = (...) => s0() +1651 -> 1652 call = (...) => s0() -1464 -> 1466 conditional = ((???*0* | []) !== {}) +1651 -> 1653 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1466 -> 1467 call = (...) => s0() +1653 -> 1654 call = (...) => s0() -1466 -> 1468 conditional = ???*0* +1653 -> 1655 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1468 -> 1469 call = (...) => s0() +1655 -> 1656 call = (...) => s0() -1468 -> 1470 conditional = ???*0* +1655 -> 1657 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1470 -> 1471 call = (...) => s0() +1657 -> 1658 call = (...) => s0() -1466 -> 1472 conditional = ???*0* +1653 -> 1659 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1472 -> 1473 call = (...) => s0() +1659 -> 1660 call = (...) => s0() -1472 -> 1474 conditional = ((???*0* | []) !== {}) +1659 -> 1661 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1474 -> 1476 member call = ???*0*["charCodeAt"](???*1*) +1661 -> 1663 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1474 -> 1477 conditional = (???*0* === 93) +1661 -> 1664 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1477 -> 1478 conditional = ((0 | ???*0*) === 0) +1664 -> 1665 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1478 -> 1479 call = (...) => (undefined | FreeVar(undefined))( +1665 -> 1666 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "]", "ignoreCase": false} ) -1474 -> 1480 conditional = ((???*0* | "]" | {}) !== {}) +1661 -> 1667 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -1480 -> 1481 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +1667 -> 1668 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1440 -> 1483 member call = (???*0* | [])["push"](???*1*) +1627 -> 1670 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1440 -> 1484 call = (...) => s0() +1627 -> 1671 call = (...) => s0() -1440 -> 1485 conditional = ???*0* +1627 -> 1672 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1485 -> 1487 member call = ???*0*["charCodeAt"](???*1*) +1672 -> 1674 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1485 -> 1488 conditional = (???*0* === 46) +1672 -> 1675 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1488 -> 1489 conditional = ((0 | ???*0*) === 0) +1675 -> 1676 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1489 -> 1490 call = (...) => (undefined | FreeVar(undefined))( +1676 -> 1677 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ".", "ignoreCase": false} ) -1485 -> 1491 conditional = ((???*0* | "." | {} | "[") !== {}) +1672 -> 1678 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1491 -> 1492 call = (...) => s0() +1678 -> 1679 call = (...) => s0() -1491 -> 1493 conditional = ((???*0* | []) !== {}) +1678 -> 1680 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1493 -> 1494 call = (...) => s0() +1680 -> 1681 call = (...) => s0() -1493 -> 1495 conditional = ???*0* +1680 -> 1682 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1495 -> 1496 call = (...) => s0() +1682 -> 1683 call = (...) => s0() -1495 -> 1497 conditional = ((???*0* | []) !== {}) +1682 -> 1684 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1497 -> 1498 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +1684 -> 1685 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1440 -> 1499 conditional = ???*0* +1627 -> 1686 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1499 -> 1500 call = (...) => s0() +1686 -> 1687 call = (...) => s0() -1499 -> 1501 conditional = ???*0* +1686 -> 1688 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1501 -> 1503 member call = ???*0*["charCodeAt"](???*1*) +1688 -> 1690 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1501 -> 1504 conditional = (???*0* === 91) +1688 -> 1691 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1504 -> 1505 conditional = ((0 | ???*0*) === 0) +1691 -> 1692 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1505 -> 1506 call = (...) => (undefined | FreeVar(undefined))( +1692 -> 1693 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "[", "ignoreCase": false} ) -1501 -> 1507 conditional = ((???*0* | "." | {} | "[") !== {}) +1688 -> 1694 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -1507 -> 1508 call = (...) => s0() +1694 -> 1695 call = (...) => s0() -1507 -> 1509 conditional = ((???*0* | []) !== {}) +1694 -> 1696 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1509 -> 1510 call = (...) => s0() +1696 -> 1697 call = (...) => s0() -1509 -> 1511 conditional = ???*0* +1696 -> 1698 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1511 -> 1512 call = (...) => s0() +1698 -> 1699 call = (...) => s0() -1511 -> 1513 conditional = ???*0* +1698 -> 1700 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1513 -> 1514 call = (...) => s0() +1700 -> 1701 call = (...) => s0() -1509 -> 1515 conditional = ???*0* +1696 -> 1702 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1515 -> 1516 call = (...) => s0() +1702 -> 1703 call = (...) => s0() -1515 -> 1517 conditional = ((???*0* | []) !== {}) +1702 -> 1704 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1517 -> 1519 member call = ???*0*["charCodeAt"](???*1*) +1704 -> 1706 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1517 -> 1520 conditional = (???*0* === 93) +1704 -> 1707 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1520 -> 1521 conditional = ((0 | ???*0*) === 0) +1707 -> 1708 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1521 -> 1522 call = (...) => (undefined | FreeVar(undefined))( +1708 -> 1709 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "]", "ignoreCase": false} ) -1517 -> 1523 conditional = ((???*0* | "]" | {}) !== {}) +1704 -> 1710 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -1523 -> 1524 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +1710 -> 1711 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1440 -> 1525 conditional = ((???*0* | []) !== {}) +1627 -> 1712 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1525 -> 1526 call = (...) => tail["reduce"](*arrow function 13694*, head)(???*0*, (???*1* | [])) +1712 -> 1713 call = (...) => tail["reduce"](*arrow function 13694*, head)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1527 call = (...) => s0() +0 -> 1714 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1715 call = (...) => s0() -0 -> 1528 conditional = ???*0* +0 -> 1716 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1528 -> 1529 call = (...) => s0() +1716 -> 1717 call = (...) => s0() -1528 -> 1530 conditional = ???*0* +1716 -> 1718 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1530 -> 1531 call = (...) => s0() +1718 -> 1719 call = (...) => s0() -1530 -> 1532 conditional = ???*0* +1718 -> 1720 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1532 -> 1533 call = (...) => s0() +1720 -> 1721 call = (...) => s0() -1532 -> 1534 conditional = ((???*0* | []) !== {}) +1720 -> 1722 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1534 -> 1535 call = (...) => s0() +1722 -> 1723 call = (...) => s0() -1534 -> 1536 conditional = ???*0* +1722 -> 1724 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1536 -> 1537 call = (...) => {"type": "scalar_unary_expression", "operator": operator, "argument": argument}(???*0*, ???*1*) +1724 -> 1725 call = (...) => {"type": "scalar_unary_expression", "operator": operator, "argument": argument}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1538 call = (...) => s0() +0 -> 1726 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1727 call = (...) => s0() -0 -> 1539 conditional = ???*0* +0 -> 1728 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1539 -> 1540 call = (...) => s0() +1728 -> 1729 call = (...) => s0() -1539 -> 1541 conditional = ((???*0* | []) !== {}) +1728 -> 1730 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1541 -> 1543 member call = ???*0*["charCodeAt"](???*1*) +1730 -> 1732 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1541 -> 1544 conditional = (???*0* === 63) +1730 -> 1733 conditional = (???*0* === 63) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1544 -> 1545 conditional = ((0 | ???*0*) === 0) +1733 -> 1734 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1545 -> 1546 call = (...) => (undefined | FreeVar(undefined))( +1734 -> 1735 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "?", "ignoreCase": false} ) -1541 -> 1547 conditional = ((???*0* | "?" | {}) !== {}) +1730 -> 1736 conditional = ((???*0* | "?" | {}) !== {}) - *0* s3 ⚠️ pattern without value -1547 -> 1548 call = (...) => s0() +1736 -> 1737 call = (...) => s0() -1547 -> 1549 conditional = ((???*0* | []) !== {}) +1736 -> 1738 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1549 -> 1550 call = (...) => s0() +1738 -> 1739 call = (...) => s0() -1549 -> 1551 conditional = ???*0* +1738 -> 1740 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1551 -> 1552 call = (...) => s0() +1740 -> 1741 call = (...) => s0() -1551 -> 1553 conditional = ((???*0* | []) !== {}) +1740 -> 1742 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1553 -> 1555 member call = ???*0*["charCodeAt"](???*1*) +1742 -> 1744 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1553 -> 1556 conditional = (???*0* === 58) +1742 -> 1745 conditional = (???*0* === 58) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1556 -> 1557 conditional = ((0 | ???*0*) === 0) +1745 -> 1746 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1557 -> 1558 call = (...) => (undefined | FreeVar(undefined))( +1746 -> 1747 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ":", "ignoreCase": false} ) -1553 -> 1559 conditional = ((???*0* | ":" | {}) !== {}) +1742 -> 1748 conditional = ((???*0* | ":" | {}) !== {}) - *0* s7 ⚠️ pattern without value -1559 -> 1560 call = (...) => s0() +1748 -> 1749 call = (...) => s0() -1559 -> 1561 conditional = ((???*0* | []) !== {}) +1748 -> 1750 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1561 -> 1562 call = (...) => s0() +1750 -> 1751 call = (...) => s0() -1561 -> 1563 conditional = ???*0* +1750 -> 1752 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1563 -> 1564 call = (...) => { +1752 -> 1753 call = (...) => { "type": "scalar_conditional_expression", "test": test, "consequent": consequent, @@ -5640,777 +6391,801 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1565 conditional = ???*0* +0 -> 1754 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1565 -> 1566 call = (...) => s0() +1754 -> 1755 call = (...) => s0() + +0 -> 1756 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1567 call = (...) => s0() +0 -> 1757 call = (...) => s0() -0 -> 1568 conditional = ???*0* +0 -> 1758 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1568 -> 1569 call = (...) => s0() +1758 -> 1759 call = (...) => s0() -1568 -> 1570 conditional = ???*0* +1758 -> 1760 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1570 -> 1571 call = (...) => s0() +1760 -> 1761 call = (...) => s0() -1570 -> 1572 conditional = ???*0* +1760 -> 1762 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1572 -> 1574 member call = ???*0*["substr"](???*1*, 2) +1762 -> 1764 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1572 -> 1575 conditional = (???*0* === "??") +1762 -> 1765 conditional = (???*0* === "??") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1575 -> 1576 conditional = ((0 | ???*0*) === 0) +1765 -> 1766 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1576 -> 1577 call = (...) => (undefined | FreeVar(undefined))( +1766 -> 1767 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "??", "ignoreCase": false} ) -1570 -> 1578 conditional = ???*0* +1760 -> 1768 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1578 -> 1579 call = (...) => s0() +1768 -> 1769 call = (...) => s0() -1578 -> 1580 conditional = ((???*0* | []) !== {}) +1768 -> 1770 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1580 -> 1581 call = (...) => s0() +1770 -> 1771 call = (...) => s0() -1568 -> 1583 member call = (???*0* | [])["push"](???*1*) +1758 -> 1773 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1568 -> 1584 call = (...) => s0() +1758 -> 1774 call = (...) => s0() -1568 -> 1585 conditional = ???*0* +1758 -> 1775 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1585 -> 1586 call = (...) => s0() +1775 -> 1776 call = (...) => s0() -1585 -> 1587 conditional = ???*0* +1775 -> 1777 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1587 -> 1589 member call = ???*0*["substr"](???*1*, 2) +1777 -> 1779 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1587 -> 1590 conditional = (???*0* === "??") +1777 -> 1780 conditional = (???*0* === "??") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1590 -> 1591 conditional = ((0 | ???*0*) === 0) +1780 -> 1781 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1591 -> 1592 call = (...) => (undefined | FreeVar(undefined))( +1781 -> 1782 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "??", "ignoreCase": false} ) -1585 -> 1593 conditional = ???*0* +1775 -> 1783 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1593 -> 1594 call = (...) => s0() +1783 -> 1784 call = (...) => s0() -1593 -> 1595 conditional = ((???*0* | []) !== {}) +1783 -> 1785 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1595 -> 1596 call = (...) => s0() +1785 -> 1786 call = (...) => s0() -1568 -> 1597 conditional = ((???*0* | []) !== {}) +1758 -> 1787 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1597 -> 1598 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1787 -> 1788 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1599 call = (...) => s0() +0 -> 1789 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1790 call = (...) => s0() -0 -> 1600 conditional = ???*0* +0 -> 1791 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1600 -> 1601 call = (...) => s0() +1791 -> 1792 call = (...) => s0() -1600 -> 1602 conditional = ???*0* +1791 -> 1793 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1602 -> 1603 call = (...) => s0() +1793 -> 1794 call = (...) => s0() -1602 -> 1604 conditional = ???*0* +1793 -> 1795 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1604 -> 1605 call = (...) => s0() +1795 -> 1796 call = (...) => s0() -1604 -> 1606 conditional = ((???*0* | []) !== {}) +1795 -> 1797 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1606 -> 1607 call = (...) => s0() +1797 -> 1798 call = (...) => s0() -1600 -> 1609 member call = (???*0* | [])["push"](???*1*) +1791 -> 1800 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1600 -> 1610 call = (...) => s0() +1791 -> 1801 call = (...) => s0() -1600 -> 1611 conditional = ???*0* +1791 -> 1802 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1611 -> 1612 call = (...) => s0() +1802 -> 1803 call = (...) => s0() -1611 -> 1613 conditional = ???*0* +1802 -> 1804 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1613 -> 1614 call = (...) => s0() +1804 -> 1805 call = (...) => s0() -1613 -> 1615 conditional = ((???*0* | []) !== {}) +1804 -> 1806 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1615 -> 1616 call = (...) => s0() +1806 -> 1807 call = (...) => s0() -1600 -> 1617 conditional = ((???*0* | []) !== {}) +1791 -> 1808 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1617 -> 1618 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1808 -> 1809 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1619 call = (...) => s0() +0 -> 1810 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1811 call = (...) => s0() -0 -> 1620 conditional = ???*0* +0 -> 1812 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1620 -> 1621 call = (...) => s0() +1812 -> 1813 call = (...) => s0() -1620 -> 1622 conditional = ???*0* +1812 -> 1814 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1622 -> 1624 member call = ???*0*["charCodeAt"](???*1*) +1814 -> 1816 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1622 -> 1625 conditional = (???*0* === 61) +1814 -> 1817 conditional = (???*0* === 61) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1625 -> 1626 conditional = ((0 | ???*0*) === 0) +1817 -> 1818 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1626 -> 1627 call = (...) => (undefined | FreeVar(undefined))( +1818 -> 1819 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "=", "ignoreCase": false} ) -1622 -> 1628 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1814 -> 1820 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1628 -> 1630 member call = ???*0*["substr"](???*1*, 2) +1820 -> 1822 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1628 -> 1631 conditional = (???*0* === "!=") +1820 -> 1823 conditional = (???*0* === "!=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1631 -> 1632 conditional = ((0 | ???*0*) === 0) +1823 -> 1824 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1632 -> 1633 call = (...) => (undefined | FreeVar(undefined))( +1824 -> 1825 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "!=", "ignoreCase": false} ) -1628 -> 1634 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1820 -> 1826 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1634 -> 1636 member call = ???*0*["substr"](???*1*, 2) +1826 -> 1828 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1634 -> 1637 conditional = (???*0* === "<>") +1826 -> 1829 conditional = (???*0* === "<>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1637 -> 1638 conditional = ((0 | ???*0*) === 0) +1829 -> 1830 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1638 -> 1639 call = (...) => (undefined | FreeVar(undefined))( +1830 -> 1831 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<>", "ignoreCase": false} ) -1622 -> 1640 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) +1814 -> 1832 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) - *0* s5 ⚠️ pattern without value -1640 -> 1641 call = (...) => s0() +1832 -> 1833 call = (...) => s0() -1640 -> 1642 conditional = ((???*0* | []) !== {}) +1832 -> 1834 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1642 -> 1643 call = (...) => s0() +1834 -> 1835 call = (...) => s0() -1620 -> 1645 member call = (???*0* | [])["push"](???*1*) +1812 -> 1837 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1620 -> 1646 call = (...) => s0() +1812 -> 1838 call = (...) => s0() -1620 -> 1647 conditional = ???*0* +1812 -> 1839 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1647 -> 1649 member call = ???*0*["charCodeAt"](???*1*) +1839 -> 1841 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1647 -> 1650 conditional = (???*0* === 61) +1839 -> 1842 conditional = (???*0* === 61) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1650 -> 1651 conditional = ((0 | ???*0*) === 0) +1842 -> 1843 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1651 -> 1652 call = (...) => (undefined | FreeVar(undefined))( +1843 -> 1844 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "=", "ignoreCase": false} ) -1647 -> 1653 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1839 -> 1845 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1653 -> 1655 member call = ???*0*["substr"](???*1*, 2) +1845 -> 1847 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1653 -> 1656 conditional = (???*0* === "!=") +1845 -> 1848 conditional = (???*0* === "!=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1656 -> 1657 conditional = ((0 | ???*0*) === 0) +1848 -> 1849 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1657 -> 1658 call = (...) => (undefined | FreeVar(undefined))( +1849 -> 1850 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "!=", "ignoreCase": false} ) -1653 -> 1659 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) +1845 -> 1851 conditional = ((???*0* | "=" | {} | "!=" | "<>") === {}) - *0* s5 ⚠️ pattern without value -1659 -> 1661 member call = ???*0*["substr"](???*1*, 2) +1851 -> 1853 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1659 -> 1662 conditional = (???*0* === "<>") +1851 -> 1854 conditional = (???*0* === "<>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1662 -> 1663 conditional = ((0 | ???*0*) === 0) +1854 -> 1855 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1663 -> 1664 call = (...) => (undefined | FreeVar(undefined))( +1855 -> 1856 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<>", "ignoreCase": false} ) -1647 -> 1665 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) +1839 -> 1857 conditional = ((???*0* | "=" | {} | "!=" | "<>") !== {}) - *0* s5 ⚠️ pattern without value -1665 -> 1666 call = (...) => s0() +1857 -> 1858 call = (...) => s0() -1665 -> 1667 conditional = ((???*0* | []) !== {}) +1857 -> 1859 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1667 -> 1668 call = (...) => s0() +1859 -> 1860 call = (...) => s0() -1620 -> 1669 conditional = ((???*0* | []) !== {}) +1812 -> 1861 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1669 -> 1670 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1861 -> 1862 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1671 call = (...) => s0() +0 -> 1863 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1864 call = (...) => s0() -0 -> 1672 conditional = ???*0* +0 -> 1865 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1672 -> 1673 call = (...) => s0() +1865 -> 1866 call = (...) => s0() -1672 -> 1674 conditional = ???*0* +1865 -> 1867 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1674 -> 1676 member call = ???*0*["substr"](???*1*, 2) +1867 -> 1869 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1674 -> 1677 conditional = (???*0* === "<=") +1867 -> 1870 conditional = (???*0* === "<=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1677 -> 1678 conditional = ((0 | ???*0*) === 0) +1870 -> 1871 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1678 -> 1679 call = (...) => (undefined | FreeVar(undefined))( +1871 -> 1872 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<=", "ignoreCase": false} ) -1674 -> 1680 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1867 -> 1873 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1680 -> 1682 member call = ???*0*["substr"](???*1*, 2) +1873 -> 1875 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1680 -> 1683 conditional = (???*0* === ">=") +1873 -> 1876 conditional = (???*0* === ">=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1683 -> 1684 conditional = ((0 | ???*0*) === 0) +1876 -> 1877 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1684 -> 1685 call = (...) => (undefined | FreeVar(undefined))( +1877 -> 1878 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">=", "ignoreCase": false} ) -1680 -> 1686 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1873 -> 1879 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1686 -> 1688 member call = ???*0*["charCodeAt"](???*1*) +1879 -> 1881 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1686 -> 1689 conditional = (???*0* === 60) +1879 -> 1882 conditional = (???*0* === 60) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1689 -> 1690 conditional = ((0 | ???*0*) === 0) +1882 -> 1883 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1690 -> 1691 call = (...) => (undefined | FreeVar(undefined))( +1883 -> 1884 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<", "ignoreCase": false} ) -1686 -> 1692 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1879 -> 1885 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1692 -> 1694 member call = ???*0*["charCodeAt"](???*1*) +1885 -> 1887 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1692 -> 1695 conditional = (???*0* === 62) +1885 -> 1888 conditional = (???*0* === 62) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1695 -> 1696 conditional = ((0 | ???*0*) === 0) +1888 -> 1889 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1696 -> 1697 call = (...) => (undefined | FreeVar(undefined))( +1889 -> 1890 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">", "ignoreCase": false} ) -1674 -> 1698 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) +1867 -> 1891 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) - *0* s5 ⚠️ pattern without value -1698 -> 1699 call = (...) => s0() +1891 -> 1892 call = (...) => s0() -1698 -> 1700 conditional = ((???*0* | []) !== {}) +1891 -> 1893 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1700 -> 1701 call = (...) => s0() +1893 -> 1894 call = (...) => s0() -1672 -> 1703 member call = (???*0* | [])["push"](???*1*) +1865 -> 1896 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1672 -> 1704 call = (...) => s0() +1865 -> 1897 call = (...) => s0() -1672 -> 1705 conditional = ???*0* +1865 -> 1898 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1705 -> 1707 member call = ???*0*["substr"](???*1*, 2) +1898 -> 1900 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1705 -> 1708 conditional = (???*0* === "<=") +1898 -> 1901 conditional = (???*0* === "<=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1708 -> 1709 conditional = ((0 | ???*0*) === 0) +1901 -> 1902 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1709 -> 1710 call = (...) => (undefined | FreeVar(undefined))( +1902 -> 1903 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<=", "ignoreCase": false} ) -1705 -> 1711 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1898 -> 1904 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1711 -> 1713 member call = ???*0*["substr"](???*1*, 2) +1904 -> 1906 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1711 -> 1714 conditional = (???*0* === ">=") +1904 -> 1907 conditional = (???*0* === ">=") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1714 -> 1715 conditional = ((0 | ???*0*) === 0) +1907 -> 1908 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1715 -> 1716 call = (...) => (undefined | FreeVar(undefined))( +1908 -> 1909 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">=", "ignoreCase": false} ) -1711 -> 1717 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1904 -> 1910 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1717 -> 1719 member call = ???*0*["charCodeAt"](???*1*) +1910 -> 1912 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1717 -> 1720 conditional = (???*0* === 60) +1910 -> 1913 conditional = (???*0* === 60) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1720 -> 1721 conditional = ((0 | ???*0*) === 0) +1913 -> 1914 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1721 -> 1722 call = (...) => (undefined | FreeVar(undefined))( +1914 -> 1915 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<", "ignoreCase": false} ) -1717 -> 1723 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) +1910 -> 1916 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") === {}) - *0* s5 ⚠️ pattern without value -1723 -> 1725 member call = ???*0*["charCodeAt"](???*1*) +1916 -> 1918 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1723 -> 1726 conditional = (???*0* === 62) +1916 -> 1919 conditional = (???*0* === 62) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1726 -> 1727 conditional = ((0 | ???*0*) === 0) +1919 -> 1920 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1727 -> 1728 call = (...) => (undefined | FreeVar(undefined))( +1920 -> 1921 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">", "ignoreCase": false} ) -1705 -> 1729 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) +1898 -> 1922 conditional = ((???*0* | "<=" | {} | ">=" | "<" | ">") !== {}) - *0* s5 ⚠️ pattern without value -1729 -> 1730 call = (...) => s0() +1922 -> 1923 call = (...) => s0() -1729 -> 1731 conditional = ((???*0* | []) !== {}) +1922 -> 1924 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1731 -> 1732 call = (...) => s0() +1924 -> 1925 call = (...) => s0() -1672 -> 1733 conditional = ((???*0* | []) !== {}) +1865 -> 1926 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1733 -> 1734 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +1926 -> 1927 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1735 call = (...) => s0() +0 -> 1928 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1929 call = (...) => s0() -0 -> 1736 conditional = ???*0* +0 -> 1930 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1736 -> 1737 call = (...) => s0() +1930 -> 1931 call = (...) => s0() -1736 -> 1738 conditional = ((???*0* | []) !== {}) +1930 -> 1932 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1738 -> 1739 call = (...) => s0() +1932 -> 1933 call = (...) => s0() -1738 -> 1740 conditional = ???*0* +1932 -> 1934 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1740 -> 1741 call = (...) => s0() +1934 -> 1935 call = (...) => s0() -1740 -> 1742 conditional = ((???*0* | []) !== {}) +1934 -> 1936 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1742 -> 1744 member call = ???*0*["charCodeAt"](???*1*) +1936 -> 1938 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1742 -> 1745 conditional = (???*0* === 40) +1936 -> 1939 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1745 -> 1746 conditional = ((0 | ???*0*) === 0) +1939 -> 1940 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1746 -> 1747 call = (...) => (undefined | FreeVar(undefined))( +1940 -> 1941 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "(", "ignoreCase": false} ) -1742 -> 1748 conditional = ((???*0* | "(" | {}) !== {}) +1936 -> 1942 conditional = ((???*0* | "(" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1748 -> 1749 call = (...) => s0() +1942 -> 1943 call = (...) => s0() -1748 -> 1750 conditional = ((???*0* | []) !== {}) +1942 -> 1944 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1750 -> 1751 call = (...) => s0() +1944 -> 1945 call = (...) => s0() -1750 -> 1752 conditional = ???*0* +1944 -> 1946 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1752 -> 1753 call = (...) => s0() +1946 -> 1947 call = (...) => s0() -1752 -> 1754 conditional = ((???*0* | []) !== {}) +1946 -> 1948 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1754 -> 1756 member call = ???*0*["charCodeAt"](???*1*) +1948 -> 1950 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1754 -> 1757 conditional = (???*0* === 41) +1948 -> 1951 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1757 -> 1758 conditional = ((0 | ???*0*) === 0) +1951 -> 1952 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1758 -> 1759 call = (...) => (undefined | FreeVar(undefined))( +1952 -> 1953 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ")", "ignoreCase": false} ) -1754 -> 1760 conditional = ((???*0* | ")" | {}) !== {}) +1948 -> 1954 conditional = ((???*0* | ")" | {}) !== {}) - *0* s9 ⚠️ pattern without value -1760 -> 1761 call = (...) => {"type": "scalar_in_expression", "value": value, "list": list}(???*0*, ???*1*) +1954 -> 1955 call = (...) => {"type": "scalar_in_expression", "value": value, "list": list}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1762 conditional = ???*0* +0 -> 1956 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1762 -> 1763 call = (...) => s0() +1956 -> 1957 call = (...) => s0() + +0 -> 1958 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1764 call = (...) => s0() +0 -> 1959 call = (...) => s0() -0 -> 1765 conditional = ???*0* +0 -> 1960 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1765 -> 1766 call = (...) => s0() +1960 -> 1961 call = (...) => s0() -1765 -> 1767 conditional = ((???*0* | []) !== {}) +1960 -> 1962 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1767 -> 1768 call = (...) => s0() +1962 -> 1963 call = (...) => s0() -1767 -> 1769 conditional = ???*0* +1962 -> 1964 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1769 -> 1770 call = (...) => s0() +1964 -> 1965 call = (...) => s0() -1769 -> 1771 conditional = ((???*0* | []) !== {}) +1964 -> 1966 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -1771 -> 1772 call = (...) => s0() +1966 -> 1967 call = (...) => s0() -1771 -> 1773 conditional = ???*0* +1966 -> 1968 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1773 -> 1774 call = (...) => s0() +1968 -> 1969 call = (...) => s0() -1773 -> 1775 conditional = ((???*0* | []) !== {}) +1968 -> 1970 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1775 -> 1776 call = (...) => s0() +1970 -> 1971 call = (...) => s0() -1775 -> 1777 conditional = ???*0* +1970 -> 1972 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1777 -> 1778 call = (...) => s0() +1972 -> 1973 call = (...) => s0() -1777 -> 1779 conditional = ((???*0* | []) !== {}) +1972 -> 1974 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -1779 -> 1780 call = (...) => s0() +1974 -> 1975 call = (...) => s0() -1779 -> 1781 conditional = ???*0* +1974 -> 1976 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1781 -> 1782 call = (...) => {"type": "scalar_between_expression", "value": value, "begin": begin, "end": end}(???*0*, ???*1*, ???*2*) +1976 -> 1977 call = (...) => {"type": "scalar_between_expression", "value": value, "begin": begin, "end": end}(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -6418,1399 +7193,1451 @@ - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1783 conditional = ???*0* +0 -> 1978 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1783 -> 1784 call = (...) => s0() +1978 -> 1979 call = (...) => s0() + +0 -> 1980 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1785 call = (...) => s0() +0 -> 1981 call = (...) => s0() -0 -> 1786 conditional = ???*0* +0 -> 1982 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1786 -> 1787 call = (...) => s0() +1982 -> 1983 call = (...) => s0() -1786 -> 1788 conditional = ???*0* +1982 -> 1984 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1788 -> 1790 member call = ???*0*["charCodeAt"](???*1*) +1984 -> 1986 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1788 -> 1791 conditional = (???*0* === 124) +1984 -> 1987 conditional = (???*0* === 124) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1791 -> 1792 conditional = ((0 | ???*0*) === 0) +1987 -> 1988 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1792 -> 1793 call = (...) => (undefined | FreeVar(undefined))( +1988 -> 1989 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "|", "ignoreCase": false} ) -1788 -> 1794 conditional = ((???*0* | "|" | {}) !== {}) +1984 -> 1990 conditional = ((???*0* | "|" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1794 -> 1795 call = (...) => s0() +1990 -> 1991 call = (...) => s0() -1794 -> 1796 conditional = ((???*0* | []) !== {}) +1990 -> 1992 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1796 -> 1797 call = (...) => s0() +1992 -> 1993 call = (...) => s0() -1786 -> 1799 member call = (???*0* | [])["push"](???*1*) +1982 -> 1995 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1786 -> 1800 call = (...) => s0() +1982 -> 1996 call = (...) => s0() -1786 -> 1801 conditional = ???*0* +1982 -> 1997 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1801 -> 1803 member call = ???*0*["charCodeAt"](???*1*) +1997 -> 1999 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1801 -> 1804 conditional = (???*0* === 124) +1997 -> 2000 conditional = (???*0* === 124) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1804 -> 1805 conditional = ((0 | ???*0*) === 0) +2000 -> 2001 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1805 -> 1806 call = (...) => (undefined | FreeVar(undefined))( +2001 -> 2002 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "|", "ignoreCase": false} ) -1801 -> 1807 conditional = ((???*0* | "|" | {}) !== {}) +1997 -> 2003 conditional = ((???*0* | "|" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1807 -> 1808 call = (...) => s0() +2003 -> 2004 call = (...) => s0() -1807 -> 1809 conditional = ((???*0* | []) !== {}) +2003 -> 2005 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1809 -> 1810 call = (...) => s0() +2005 -> 2006 call = (...) => s0() -1786 -> 1811 conditional = ((???*0* | []) !== {}) +1982 -> 2007 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1811 -> 1812 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2007 -> 2008 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1813 call = (...) => s0() +0 -> 2009 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2010 call = (...) => s0() -0 -> 1814 conditional = ???*0* +0 -> 2011 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1814 -> 1815 call = (...) => s0() +2011 -> 2012 call = (...) => s0() -1814 -> 1816 conditional = ???*0* +2011 -> 2013 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1816 -> 1818 member call = ???*0*["charCodeAt"](???*1*) +2013 -> 2015 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1816 -> 1819 conditional = (???*0* === 94) +2013 -> 2016 conditional = (???*0* === 94) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1819 -> 1820 conditional = ((0 | ???*0*) === 0) +2016 -> 2017 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1820 -> 1821 call = (...) => (undefined | FreeVar(undefined))( +2017 -> 2018 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "^", "ignoreCase": false} ) -1816 -> 1822 conditional = ((???*0* | "^" | {}) !== {}) +2013 -> 2019 conditional = ((???*0* | "^" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1822 -> 1823 call = (...) => s0() +2019 -> 2020 call = (...) => s0() -1822 -> 1824 conditional = ((???*0* | []) !== {}) +2019 -> 2021 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1824 -> 1825 call = (...) => s0() +2021 -> 2022 call = (...) => s0() -1814 -> 1827 member call = (???*0* | [])["push"](???*1*) +2011 -> 2024 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1814 -> 1828 call = (...) => s0() +2011 -> 2025 call = (...) => s0() -1814 -> 1829 conditional = ???*0* +2011 -> 2026 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1829 -> 1831 member call = ???*0*["charCodeAt"](???*1*) +2026 -> 2028 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1829 -> 1832 conditional = (???*0* === 94) +2026 -> 2029 conditional = (???*0* === 94) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1832 -> 1833 conditional = ((0 | ???*0*) === 0) +2029 -> 2030 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1833 -> 1834 call = (...) => (undefined | FreeVar(undefined))( +2030 -> 2031 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "^", "ignoreCase": false} ) -1829 -> 1835 conditional = ((???*0* | "^" | {}) !== {}) +2026 -> 2032 conditional = ((???*0* | "^" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1835 -> 1836 call = (...) => s0() +2032 -> 2033 call = (...) => s0() -1835 -> 1837 conditional = ((???*0* | []) !== {}) +2032 -> 2034 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1837 -> 1838 call = (...) => s0() +2034 -> 2035 call = (...) => s0() -1814 -> 1839 conditional = ((???*0* | []) !== {}) +2011 -> 2036 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1839 -> 1840 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2036 -> 2037 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1841 call = (...) => s0() +0 -> 2038 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2039 call = (...) => s0() -0 -> 1842 conditional = ???*0* +0 -> 2040 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1842 -> 1843 call = (...) => s0() +2040 -> 2041 call = (...) => s0() -1842 -> 1844 conditional = ???*0* +2040 -> 2042 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1844 -> 1846 member call = ???*0*["charCodeAt"](???*1*) +2042 -> 2044 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1844 -> 1847 conditional = (???*0* === 38) +2042 -> 2045 conditional = (???*0* === 38) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1847 -> 1848 conditional = ((0 | ???*0*) === 0) +2045 -> 2046 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1848 -> 1849 call = (...) => (undefined | FreeVar(undefined))( +2046 -> 2047 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "&", "ignoreCase": false} ) -1844 -> 1850 conditional = ((???*0* | "&" | {}) !== {}) +2042 -> 2048 conditional = ((???*0* | "&" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1850 -> 1851 call = (...) => s0() +2048 -> 2049 call = (...) => s0() -1850 -> 1852 conditional = ((???*0* | []) !== {}) +2048 -> 2050 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1852 -> 1853 call = (...) => s0() +2050 -> 2051 call = (...) => s0() -1842 -> 1855 member call = (???*0* | [])["push"](???*1*) +2040 -> 2053 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1842 -> 1856 call = (...) => s0() +2040 -> 2054 call = (...) => s0() -1842 -> 1857 conditional = ???*0* +2040 -> 2055 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1857 -> 1859 member call = ???*0*["charCodeAt"](???*1*) +2055 -> 2057 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1857 -> 1860 conditional = (???*0* === 38) +2055 -> 2058 conditional = (???*0* === 38) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1860 -> 1861 conditional = ((0 | ???*0*) === 0) +2058 -> 2059 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1861 -> 1862 call = (...) => (undefined | FreeVar(undefined))( +2059 -> 2060 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "&", "ignoreCase": false} ) -1857 -> 1863 conditional = ((???*0* | "&" | {}) !== {}) +2055 -> 2061 conditional = ((???*0* | "&" | {}) !== {}) - *0* s5 ⚠️ pattern without value -1863 -> 1864 call = (...) => s0() +2061 -> 2062 call = (...) => s0() -1863 -> 1865 conditional = ((???*0* | []) !== {}) +2061 -> 2063 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1865 -> 1866 call = (...) => s0() +2063 -> 2064 call = (...) => s0() -1842 -> 1867 conditional = ((???*0* | []) !== {}) +2040 -> 2065 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1867 -> 1868 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2065 -> 2066 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1869 call = (...) => s0() +0 -> 2067 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2068 call = (...) => s0() -0 -> 1870 conditional = ???*0* +0 -> 2069 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1870 -> 1871 call = (...) => s0() +2069 -> 2070 call = (...) => s0() -1870 -> 1872 conditional = ???*0* +2069 -> 2071 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1872 -> 1874 member call = ???*0*["substr"](???*1*, 2) +2071 -> 2073 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1872 -> 1875 conditional = (???*0* === "<<") +2071 -> 2074 conditional = (???*0* === "<<") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1875 -> 1876 conditional = ((0 | ???*0*) === 0) +2074 -> 2075 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1876 -> 1877 call = (...) => (undefined | FreeVar(undefined))( +2075 -> 2076 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<<", "ignoreCase": false} ) -1872 -> 1878 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2071 -> 2077 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -1878 -> 1880 member call = ???*0*["substr"](???*1*, 3) +2077 -> 2079 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1878 -> 1881 conditional = (???*0* === ">>>") +2077 -> 2080 conditional = (???*0* === ">>>") - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1881 -> 1882 conditional = ((0 | ???*0*) === 0) +2080 -> 2081 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1882 -> 1883 call = (...) => (undefined | FreeVar(undefined))( +2081 -> 2082 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">>>", "ignoreCase": false} ) -1878 -> 1884 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2077 -> 2083 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -1884 -> 1886 member call = ???*0*["substr"](???*1*, 2) +2083 -> 2085 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1884 -> 1887 conditional = (???*0* === ">>") +2083 -> 2086 conditional = (???*0* === ">>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1887 -> 1888 conditional = ((0 | ???*0*) === 0) +2086 -> 2087 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1888 -> 1889 call = (...) => (undefined | FreeVar(undefined))( +2087 -> 2088 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">>", "ignoreCase": false} ) -1872 -> 1890 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) +2071 -> 2089 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) - *0* s5 ⚠️ pattern without value -1890 -> 1891 call = (...) => s0() +2089 -> 2090 call = (...) => s0() -1890 -> 1892 conditional = ((???*0* | []) !== {}) +2089 -> 2091 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1892 -> 1893 call = (...) => s0() +2091 -> 2092 call = (...) => s0() -1870 -> 1895 member call = (???*0* | [])["push"](???*1*) +2069 -> 2094 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1870 -> 1896 call = (...) => s0() +2069 -> 2095 call = (...) => s0() -1870 -> 1897 conditional = ???*0* +2069 -> 2096 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1897 -> 1899 member call = ???*0*["substr"](???*1*, 2) +2096 -> 2098 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1897 -> 1900 conditional = (???*0* === "<<") +2096 -> 2099 conditional = (???*0* === "<<") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1900 -> 1901 conditional = ((0 | ???*0*) === 0) +2099 -> 2100 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1901 -> 1902 call = (...) => (undefined | FreeVar(undefined))( +2100 -> 2101 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "<<", "ignoreCase": false} ) -1897 -> 1903 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2096 -> 2102 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -1903 -> 1905 member call = ???*0*["substr"](???*1*, 3) +2102 -> 2104 member call = ???*0*["substr"](???*1*, 3) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1903 -> 1906 conditional = (???*0* === ">>>") +2102 -> 2105 conditional = (???*0* === ">>>") - *0* ???*1*["substr"](peg$currPos, 3) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1906 -> 1907 conditional = ((0 | ???*0*) === 0) +2105 -> 2106 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1907 -> 1908 call = (...) => (undefined | FreeVar(undefined))( +2106 -> 2107 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">>>", "ignoreCase": false} ) -1903 -> 1909 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) +2102 -> 2108 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") === {}) - *0* s5 ⚠️ pattern without value -1909 -> 1911 member call = ???*0*["substr"](???*1*, 2) +2108 -> 2110 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1909 -> 1912 conditional = (???*0* === ">>") +2108 -> 2111 conditional = (???*0* === ">>") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1912 -> 1913 conditional = ((0 | ???*0*) === 0) +2111 -> 2112 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1913 -> 1914 call = (...) => (undefined | FreeVar(undefined))( +2112 -> 2113 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ">>", "ignoreCase": false} ) -1897 -> 1915 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) +2096 -> 2114 conditional = ((???*0* | "<<" | {} | ">>>" | ">>") !== {}) - *0* s5 ⚠️ pattern without value -1915 -> 1916 call = (...) => s0() +2114 -> 2115 call = (...) => s0() -1915 -> 1917 conditional = ((???*0* | []) !== {}) +2114 -> 2116 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1917 -> 1918 call = (...) => s0() +2116 -> 2117 call = (...) => s0() -1870 -> 1919 conditional = ((???*0* | []) !== {}) +2069 -> 2118 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1919 -> 1920 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2118 -> 2119 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1921 call = (...) => s0() +0 -> 2120 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2121 call = (...) => s0() -0 -> 1922 conditional = ???*0* +0 -> 2122 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1922 -> 1923 call = (...) => s0() +2122 -> 2123 call = (...) => s0() -1922 -> 1924 conditional = ???*0* +2122 -> 2124 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1924 -> 1926 member call = ???*0*["charCodeAt"](???*1*) +2124 -> 2126 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1924 -> 1927 conditional = (???*0* === 43) +2124 -> 2127 conditional = (???*0* === 43) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1927 -> 1928 conditional = ((0 | ???*0*) === 0) +2127 -> 2128 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1928 -> 1929 call = (...) => (undefined | FreeVar(undefined))( +2128 -> 2129 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "+", "ignoreCase": false} ) -1924 -> 1930 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2124 -> 2130 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -1930 -> 1932 member call = ???*0*["charCodeAt"](???*1*) +2130 -> 2132 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1930 -> 1933 conditional = (???*0* === 45) +2130 -> 2133 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1933 -> 1934 conditional = ((0 | ???*0*) === 0) +2133 -> 2134 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1934 -> 1935 call = (...) => (undefined | FreeVar(undefined))( +2134 -> 2135 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "-", "ignoreCase": false} ) -1930 -> 1936 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2130 -> 2136 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -1936 -> 1938 member call = ???*0*["substr"](???*1*, 2) +2136 -> 2138 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1936 -> 1939 conditional = (???*0* === "||") +2136 -> 2139 conditional = (???*0* === "||") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1939 -> 1940 conditional = ((0 | ???*0*) === 0) +2139 -> 2140 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1940 -> 1941 call = (...) => (undefined | FreeVar(undefined))( +2140 -> 2141 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "||", "ignoreCase": false} ) -1924 -> 1942 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) +2124 -> 2142 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) - *0* s5 ⚠️ pattern without value -1942 -> 1943 call = (...) => s0() +2142 -> 2143 call = (...) => s0() -1942 -> 1944 conditional = ((???*0* | []) !== {}) +2142 -> 2144 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1944 -> 1945 call = (...) => s0() +2144 -> 2145 call = (...) => s0() -1922 -> 1947 member call = (???*0* | [])["push"](???*1*) +2122 -> 2147 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1922 -> 1948 call = (...) => s0() +2122 -> 2148 call = (...) => s0() -1922 -> 1949 conditional = ???*0* +2122 -> 2149 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1949 -> 1951 member call = ???*0*["charCodeAt"](???*1*) +2149 -> 2151 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1949 -> 1952 conditional = (???*0* === 43) +2149 -> 2152 conditional = (???*0* === 43) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1952 -> 1953 conditional = ((0 | ???*0*) === 0) +2152 -> 2153 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1953 -> 1954 call = (...) => (undefined | FreeVar(undefined))( +2153 -> 2154 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "+", "ignoreCase": false} ) -1949 -> 1955 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2149 -> 2155 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -1955 -> 1957 member call = ???*0*["charCodeAt"](???*1*) +2155 -> 2157 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1955 -> 1958 conditional = (???*0* === 45) +2155 -> 2158 conditional = (???*0* === 45) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1958 -> 1959 conditional = ((0 | ???*0*) === 0) +2158 -> 2159 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1959 -> 1960 call = (...) => (undefined | FreeVar(undefined))( +2159 -> 2160 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "-", "ignoreCase": false} ) -1955 -> 1961 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) +2155 -> 2161 conditional = ((???*0* | "+" | {} | "-" | "||") === {}) - *0* s5 ⚠️ pattern without value -1961 -> 1963 member call = ???*0*["substr"](???*1*, 2) +2161 -> 2163 member call = ???*0*["substr"](???*1*, 2) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1961 -> 1964 conditional = (???*0* === "||") +2161 -> 2164 conditional = (???*0* === "||") - *0* ???*1*["substr"](peg$currPos, 2) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1964 -> 1965 conditional = ((0 | ???*0*) === 0) +2164 -> 2165 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1965 -> 1966 call = (...) => (undefined | FreeVar(undefined))( +2165 -> 2166 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "||", "ignoreCase": false} ) -1949 -> 1967 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) +2149 -> 2167 conditional = ((???*0* | "+" | {} | "-" | "||") !== {}) - *0* s5 ⚠️ pattern without value -1967 -> 1968 call = (...) => s0() +2167 -> 2168 call = (...) => s0() -1967 -> 1969 conditional = ((???*0* | []) !== {}) +2167 -> 2169 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1969 -> 1970 call = (...) => s0() +2169 -> 2170 call = (...) => s0() -1922 -> 1971 conditional = ((???*0* | []) !== {}) +2122 -> 2171 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -1971 -> 1972 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2171 -> 2172 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 1973 call = (...) => s0() +0 -> 2173 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2174 call = (...) => s0() -0 -> 1974 conditional = ???*0* +0 -> 2175 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1974 -> 1975 call = (...) => s0() +2175 -> 2176 call = (...) => s0() -1974 -> 1976 conditional = ???*0* +2175 -> 2177 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1976 -> 1978 member call = ???*0*["charCodeAt"](???*1*) +2177 -> 2179 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1976 -> 1979 conditional = (???*0* === 42) +2177 -> 2180 conditional = (???*0* === 42) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1979 -> 1980 conditional = ((0 | ???*0*) === 0) +2180 -> 2181 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1980 -> 1981 call = (...) => (undefined | FreeVar(undefined))( +2181 -> 2182 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "*", "ignoreCase": false} ) -1976 -> 1982 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2177 -> 2183 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -1982 -> 1984 member call = ???*0*["charCodeAt"](???*1*) +2183 -> 2185 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1982 -> 1985 conditional = (???*0* === 47) +2183 -> 2186 conditional = (???*0* === 47) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1985 -> 1986 conditional = ((0 | ???*0*) === 0) +2186 -> 2187 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1986 -> 1987 call = (...) => (undefined | FreeVar(undefined))( +2187 -> 2188 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "/", "ignoreCase": false} ) -1982 -> 1988 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2183 -> 2189 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -1988 -> 1990 member call = ???*0*["charCodeAt"](???*1*) +2189 -> 2191 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -1988 -> 1991 conditional = (???*0* === 37) +2189 -> 2192 conditional = (???*0* === 37) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -1991 -> 1992 conditional = ((0 | ???*0*) === 0) +2192 -> 2193 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -1992 -> 1993 call = (...) => (undefined | FreeVar(undefined))( +2193 -> 2194 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "%", "ignoreCase": false} ) -1976 -> 1994 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) +2177 -> 2195 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) - *0* s5 ⚠️ pattern without value -1994 -> 1995 call = (...) => s0() +2195 -> 2196 call = (...) => s0() -1994 -> 1996 conditional = ((???*0* | []) !== {}) +2195 -> 2197 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -1996 -> 1997 call = (...) => s0() +2197 -> 2198 call = (...) => s0() -1974 -> 1999 member call = (???*0* | [])["push"](???*1*) +2175 -> 2200 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1974 -> 2000 call = (...) => s0() +2175 -> 2201 call = (...) => s0() -1974 -> 2001 conditional = ???*0* +2175 -> 2202 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2001 -> 2003 member call = ???*0*["charCodeAt"](???*1*) +2202 -> 2204 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2001 -> 2004 conditional = (???*0* === 42) +2202 -> 2205 conditional = (???*0* === 42) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2004 -> 2005 conditional = ((0 | ???*0*) === 0) +2205 -> 2206 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2005 -> 2006 call = (...) => (undefined | FreeVar(undefined))( +2206 -> 2207 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "*", "ignoreCase": false} ) -2001 -> 2007 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2202 -> 2208 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -2007 -> 2009 member call = ???*0*["charCodeAt"](???*1*) +2208 -> 2210 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2007 -> 2010 conditional = (???*0* === 47) +2208 -> 2211 conditional = (???*0* === 47) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2010 -> 2011 conditional = ((0 | ???*0*) === 0) +2211 -> 2212 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2011 -> 2012 call = (...) => (undefined | FreeVar(undefined))( +2212 -> 2213 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "/", "ignoreCase": false} ) -2007 -> 2013 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) +2208 -> 2214 conditional = ((???*0* | "*" | {} | "/" | "%") === {}) - *0* s5 ⚠️ pattern without value -2013 -> 2015 member call = ???*0*["charCodeAt"](???*1*) +2214 -> 2216 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2013 -> 2016 conditional = (???*0* === 37) +2214 -> 2217 conditional = (???*0* === 37) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2016 -> 2017 conditional = ((0 | ???*0*) === 0) +2217 -> 2218 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2017 -> 2018 call = (...) => (undefined | FreeVar(undefined))( +2218 -> 2219 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "%", "ignoreCase": false} ) -2001 -> 2019 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) +2202 -> 2220 conditional = ((???*0* | "*" | {} | "/" | "%") !== {}) - *0* s5 ⚠️ pattern without value -2019 -> 2020 call = (...) => s0() +2220 -> 2221 call = (...) => s0() -2019 -> 2021 conditional = ((???*0* | []) !== {}) +2220 -> 2222 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2021 -> 2022 call = (...) => s0() +2222 -> 2223 call = (...) => s0() -1974 -> 2023 conditional = ((???*0* | []) !== {}) +2175 -> 2224 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2023 -> 2024 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) +2224 -> 2225 call = (...) => buildBinaryExpression(head, tail)(???*0*, (???*1* | [])) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2025 call = (...) => s0() +0 -> 2226 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2227 call = (...) => s0() -0 -> 2026 conditional = ???*0* +0 -> 2228 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2026 -> 2027 call = (...) => s0() +2228 -> 2229 call = (...) => s0() -0 -> 2028 conditional = ???*0* +0 -> 2230 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2028 -> 2029 call = (...) => s0() +2230 -> 2231 call = (...) => s0() -2028 -> 2030 conditional = ((???*0* | []) !== {}) +2230 -> 2232 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2030 -> 2032 member call = ???*0*["charCodeAt"](???*1*) +2232 -> 2234 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2030 -> 2033 conditional = (???*0* === 58) +2232 -> 2235 conditional = (???*0* === 58) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2033 -> 2034 conditional = ((0 | ???*0*) === 0) +2235 -> 2236 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2034 -> 2035 call = (...) => (undefined | FreeVar(undefined))( +2236 -> 2237 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ":", "ignoreCase": false} ) -2030 -> 2036 conditional = ((???*0* | ":" | {}) !== {}) +2232 -> 2238 conditional = ((???*0* | ":" | {}) !== {}) - *0* s3 ⚠️ pattern without value -2036 -> 2037 call = (...) => s0() +2238 -> 2239 call = (...) => s0() -2036 -> 2038 conditional = ((???*0* | []) !== {}) +2238 -> 2240 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -2038 -> 2039 call = (...) => s0() +2240 -> 2241 call = (...) => s0() -2038 -> 2040 conditional = ???*0* +2240 -> 2242 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2040 -> 2041 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) +2242 -> 2243 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2042 call = (...) => s0() +0 -> 2244 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2245 call = (...) => s0() -0 -> 2043 conditional = ???*0* +0 -> 2246 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2043 -> 2044 call = (...) => s0() +2246 -> 2247 call = (...) => s0() -0 -> 2045 conditional = ???*0* +0 -> 2248 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2045 -> 2046 call = (...) => s0() +2248 -> 2249 call = (...) => s0() -2045 -> 2047 conditional = ((???*0* | []) !== {}) +2248 -> 2250 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2047 -> 2049 member call = ???*0*["charCodeAt"](???*1*) +2250 -> 2252 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2047 -> 2050 conditional = (???*0* === 58) +2250 -> 2253 conditional = (???*0* === 58) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2050 -> 2051 conditional = ((0 | ???*0*) === 0) +2253 -> 2254 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2051 -> 2052 call = (...) => (undefined | FreeVar(undefined))( +2254 -> 2255 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ":", "ignoreCase": false} ) -2047 -> 2053 conditional = ((???*0* | ":" | {}) !== {}) +2250 -> 2256 conditional = ((???*0* | ":" | {}) !== {}) - *0* s3 ⚠️ pattern without value -2053 -> 2054 call = (...) => s0() +2256 -> 2257 call = (...) => s0() -2053 -> 2055 conditional = ((???*0* | []) !== {}) +2256 -> 2258 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -2055 -> 2056 call = (...) => s0() +2258 -> 2259 call = (...) => s0() -2055 -> 2057 conditional = ???*0* +2258 -> 2260 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2057 -> 2058 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) +2260 -> 2261 call = (...) => {"key": key, "value": value}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2059 call = (...) => s0() +0 -> 2262 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2263 call = (...) => s0() -0 -> 2060 conditional = ???*0* +0 -> 2264 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2060 -> 2061 call = (...) => {"type": "collection_expression", "expression": expression}(???*0*) +2264 -> 2265 call = (...) => {"type": "collection_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2062 call = (...) => s0() +0 -> 2266 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2267 call = (...) => s0() -0 -> 2063 conditional = ???*0* +0 -> 2268 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2063 -> 2064 call = (...) => s0() +2268 -> 2269 call = (...) => s0() -2063 -> 2065 conditional = ???*0* +2268 -> 2270 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2065 -> 2067 member call = ???*0*["charCodeAt"](???*1*) +2270 -> 2272 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2065 -> 2068 conditional = (???*0* === 46) +2270 -> 2273 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2068 -> 2069 conditional = ((0 | ???*0*) === 0) +2273 -> 2274 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2069 -> 2070 call = (...) => (undefined | FreeVar(undefined))( +2274 -> 2275 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ".", "ignoreCase": false} ) -2065 -> 2071 conditional = ((???*0* | "." | {} | "[") !== {}) +2270 -> 2276 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2071 -> 2072 call = (...) => s0() +2276 -> 2277 call = (...) => s0() -2071 -> 2073 conditional = ((???*0* | []) !== {}) +2276 -> 2278 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2073 -> 2074 call = (...) => s0() +2278 -> 2279 call = (...) => s0() -2073 -> 2075 conditional = ???*0* +2278 -> 2280 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2075 -> 2076 call = (...) => s0() +2280 -> 2281 call = (...) => s0() -2075 -> 2077 conditional = ((???*0* | []) !== {}) +2280 -> 2282 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2077 -> 2078 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +2282 -> 2283 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2063 -> 2079 conditional = ???*0* +2268 -> 2284 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2079 -> 2080 call = (...) => s0() +2284 -> 2285 call = (...) => s0() -2079 -> 2081 conditional = ???*0* +2284 -> 2286 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2081 -> 2083 member call = ???*0*["charCodeAt"](???*1*) +2286 -> 2288 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2081 -> 2084 conditional = (???*0* === 91) +2286 -> 2289 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2084 -> 2085 conditional = ((0 | ???*0*) === 0) +2289 -> 2290 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2085 -> 2086 call = (...) => (undefined | FreeVar(undefined))( +2290 -> 2291 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "[", "ignoreCase": false} ) -2081 -> 2087 conditional = ((???*0* | "." | {} | "[") !== {}) +2286 -> 2292 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2087 -> 2088 call = (...) => s0() +2292 -> 2293 call = (...) => s0() -2087 -> 2089 conditional = ((???*0* | []) !== {}) +2292 -> 2294 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2089 -> 2090 call = (...) => s0() +2294 -> 2295 call = (...) => s0() -2089 -> 2091 conditional = ???*0* +2294 -> 2296 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2091 -> 2092 call = (...) => s0() +2296 -> 2297 call = (...) => s0() -2091 -> 2093 conditional = ???*0* +2296 -> 2298 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2093 -> 2094 call = (...) => s0() +2298 -> 2299 call = (...) => s0() -2089 -> 2095 conditional = ???*0* +2294 -> 2300 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2095 -> 2096 call = (...) => s0() +2300 -> 2301 call = (...) => s0() -2095 -> 2097 conditional = ((???*0* | []) !== {}) +2300 -> 2302 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2097 -> 2099 member call = ???*0*["charCodeAt"](???*1*) +2302 -> 2304 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2097 -> 2100 conditional = (???*0* === 93) +2302 -> 2305 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2100 -> 2101 conditional = ((0 | ???*0*) === 0) +2305 -> 2306 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2101 -> 2102 call = (...) => (undefined | FreeVar(undefined))( +2306 -> 2307 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "]", "ignoreCase": false} ) -2097 -> 2103 conditional = ((???*0* | "]" | {}) !== {}) +2302 -> 2308 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -2103 -> 2104 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +2308 -> 2309 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2063 -> 2105 conditional = ???*0* +2268 -> 2310 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2105 -> 2107 member call = (???*0* | [] | {})["push"](???*1*) +2310 -> 2312 member call = (???*0* | [] | {})["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2105 -> 2108 call = (...) => s0() +2310 -> 2313 call = (...) => s0() -2105 -> 2109 conditional = ???*0* +2310 -> 2314 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2109 -> 2111 member call = ???*0*["charCodeAt"](???*1*) +2314 -> 2316 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2109 -> 2112 conditional = (???*0* === 46) +2314 -> 2317 conditional = (???*0* === 46) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2112 -> 2113 conditional = ((0 | ???*0*) === 0) +2317 -> 2318 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2113 -> 2114 call = (...) => (undefined | FreeVar(undefined))( +2318 -> 2319 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ".", "ignoreCase": false} ) -2109 -> 2115 conditional = ((???*0* | "." | {} | "[") !== {}) +2314 -> 2320 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2115 -> 2116 call = (...) => s0() +2320 -> 2321 call = (...) => s0() -2115 -> 2117 conditional = ((???*0* | []) !== {}) +2320 -> 2322 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2117 -> 2118 call = (...) => s0() +2322 -> 2323 call = (...) => s0() -2117 -> 2119 conditional = ???*0* +2322 -> 2324 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2119 -> 2120 call = (...) => s0() +2324 -> 2325 call = (...) => s0() -2119 -> 2121 conditional = ((???*0* | []) !== {}) +2324 -> 2326 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2121 -> 2122 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) +2326 -> 2327 call = (...) => {"property": property, "computed": false}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2105 -> 2123 conditional = ???*0* +2310 -> 2328 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2123 -> 2124 call = (...) => s0() +2328 -> 2329 call = (...) => s0() -2123 -> 2125 conditional = ???*0* +2328 -> 2330 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2125 -> 2127 member call = ???*0*["charCodeAt"](???*1*) +2330 -> 2332 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2125 -> 2128 conditional = (???*0* === 91) +2330 -> 2333 conditional = (???*0* === 91) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2128 -> 2129 conditional = ((0 | ???*0*) === 0) +2333 -> 2334 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2129 -> 2130 call = (...) => (undefined | FreeVar(undefined))( +2334 -> 2335 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "[", "ignoreCase": false} ) -2125 -> 2131 conditional = ((???*0* | "." | {} | "[") !== {}) +2330 -> 2336 conditional = ((???*0* | "." | {} | "[") !== {}) - *0* s5 ⚠️ pattern without value -2131 -> 2132 call = (...) => s0() +2336 -> 2337 call = (...) => s0() -2131 -> 2133 conditional = ((???*0* | []) !== {}) +2336 -> 2338 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2133 -> 2134 call = (...) => s0() +2338 -> 2339 call = (...) => s0() -2133 -> 2135 conditional = ???*0* +2338 -> 2340 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2135 -> 2136 call = (...) => s0() +2340 -> 2341 call = (...) => s0() -2135 -> 2137 conditional = ???*0* +2340 -> 2342 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2137 -> 2138 call = (...) => s0() +2342 -> 2343 call = (...) => s0() -2133 -> 2139 conditional = ???*0* +2338 -> 2344 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2139 -> 2140 call = (...) => s0() +2344 -> 2345 call = (...) => s0() -2139 -> 2141 conditional = ((???*0* | []) !== {}) +2344 -> 2346 conditional = ((???*0* | []) !== {}) - *0* s8 ⚠️ pattern without value -2141 -> 2143 member call = ???*0*["charCodeAt"](???*1*) +2346 -> 2348 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2141 -> 2144 conditional = (???*0* === 93) +2346 -> 2349 conditional = (???*0* === 93) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2144 -> 2145 conditional = ((0 | ???*0*) === 0) +2349 -> 2350 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2145 -> 2146 call = (...) => (undefined | FreeVar(undefined))( +2350 -> 2351 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "]", "ignoreCase": false} ) -2141 -> 2147 conditional = ((???*0* | "]" | {}) !== {}) +2346 -> 2352 conditional = ((???*0* | "]" | {}) !== {}) - *0* s9 ⚠️ pattern without value -2147 -> 2148 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) +2352 -> 2353 call = (...) => {"property": property, "computed": true}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2063 -> 2149 conditional = ((???*0* | [] | {}) !== {}) +2268 -> 2354 conditional = ((???*0* | [] | {}) !== {}) - *0* s2 ⚠️ pattern without value -2149 -> 2150 call = (...) => tail["reduce"](*arrow function 16259*, head)(???*0*, (???*1* | [] | {})) +2354 -> 2355 call = (...) => tail["reduce"](*arrow function 16259*, head)(???*0*, (???*1* | [] | {})) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* s2 ⚠️ pattern without value -0 -> 2151 call = (...) => s0() +0 -> 2356 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2357 call = (...) => s0() -0 -> 2152 conditional = ???*0* +0 -> 2358 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2152 -> 2153 call = (...) => {"type": "collection_subquery_expression", "expression": expression}(???*0*) +2358 -> 2359 call = (...) => {"type": "collection_subquery_expression", "expression": expression}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2154 call = (...) => s0() +0 -> 2360 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2361 call = (...) => s0() -0 -> 2155 conditional = ???*0* +0 -> 2362 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2155 -> 2156 call = (...) => s0() +2362 -> 2363 call = (...) => s0() -0 -> 2157 conditional = ???*0* +0 -> 2364 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2157 -> 2158 call = (...) => {"type": "top_specification", "value": value}(???*0*) +2364 -> 2365 call = (...) => {"type": "top_specification", "value": value}(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2161 member call = ???*0*["charAt"](???*1*) +0 -> 2366 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2369 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2162 member call = /^[0-9]/["test"](???*0*) +0 -> 2370 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2163 conditional = /^[0-9]/["test"](???*0*) +0 -> 2371 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2163 -> 2165 member call = ???*0*["charAt"](???*1*) +2371 -> 2373 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2163 -> 2166 conditional = ((0 | ???*0*) === 0) +2371 -> 2374 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2166 -> 2167 call = (...) => (undefined | FreeVar(undefined))( +2374 -> 2375 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -0 -> 2168 conditional = ((???*0* | ???*1* | {}) !== {}) +0 -> 2376 conditional = ((???*0* | ???*1* | {}) !== {}) - *0* s2 ⚠️ pattern without value - *1* ???*2*["charAt"](peg$currPos) @@ -7818,7 +8645,7 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -2168 -> 2170 member call = (???*0* | [] | {} | {"type": "number_constant", "value": ???*1*})["push"]((???*3* | ???*4* | {})) +2376 -> 2378 member call = (???*0* | [] | {} | {"type": "number_constant", "value": ???*1*})["push"]((???*3* | ???*4* | {})) - *0* s1 ⚠️ pattern without value - *1* ???*2*(text()) @@ -7834,39 +8661,39 @@ - *5* arguments[0] ⚠️ function calls are not analysed yet -2168 -> 2173 member call = ???*0*["charAt"](???*1*) +2376 -> 2381 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2168 -> 2174 member call = /^[0-9]/["test"](???*0*) +2376 -> 2382 member call = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2168 -> 2175 conditional = /^[0-9]/["test"](???*0*) +2376 -> 2383 conditional = /^[0-9]/["test"](???*0*) - *0* ???*1*["charAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2175 -> 2177 member call = ???*0*["charAt"](???*1*) +2383 -> 2385 member call = ???*0*["charAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2175 -> 2178 conditional = ((0 | ???*0*) === 0) +2383 -> 2386 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2178 -> 2179 call = (...) => (undefined | FreeVar(undefined))( +2386 -> 2387 call = (...) => (undefined | FreeVar(undefined))( {"type": "class", "parts": [["0", "9"]], "inverted": false, "ignoreCase": false} ) -0 -> 2180 conditional = ((???*0* | [] | {} | {"type": "number_constant", "value": ???*1*}) !== {}) +0 -> 2388 conditional = ((???*0* | [] | {} | {"type": "number_constant", "value": ???*1*}) !== {}) - *0* s1 ⚠️ pattern without value - *1* ???*2*(text()) @@ -7876,121 +8703,125 @@ ⚠️ unknown global ⚠️ This value might have side effects -2180 -> 2181 call = (...) => {"type": "number_constant", "value": FreeVar(Number)(text())}() +2388 -> 2389 call = (...) => {"type": "number_constant", "value": FreeVar(Number)(text())}() + +0 -> 2390 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 2182 call = (...) => s0() +0 -> 2391 call = (...) => s0() -0 -> 2183 conditional = ???*0* +0 -> 2392 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2183 -> 2184 call = (...) => s0() +2392 -> 2393 call = (...) => s0() -2183 -> 2185 conditional = ???*0* +2392 -> 2394 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2185 -> 2187 member call = ???*0*["charCodeAt"](???*1*) +2394 -> 2396 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2185 -> 2188 conditional = (???*0* === 44) +2394 -> 2397 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2188 -> 2189 conditional = ((0 | ???*0*) === 0) +2397 -> 2398 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2189 -> 2190 call = (...) => (undefined | FreeVar(undefined))( +2398 -> 2399 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -2185 -> 2191 conditional = ((???*0* | "," | {}) !== {}) +2394 -> 2400 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -2191 -> 2192 call = (...) => s0() +2400 -> 2401 call = (...) => s0() -2191 -> 2193 conditional = ((???*0* | []) !== {}) +2400 -> 2402 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2193 -> 2194 call = (...) => s0() +2402 -> 2403 call = (...) => s0() -2193 -> 2195 conditional = ???*0* +2402 -> 2404 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2195 -> 2196 call = (...) => v(???*0*, ???*1*) +2404 -> 2405 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2183 -> 2198 member call = (???*0* | [])["push"](???*1*) +2392 -> 2407 member call = (???*0* | [])["push"](???*1*) - *0* s2 ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -2183 -> 2199 call = (...) => s0() +2392 -> 2408 call = (...) => s0() -2183 -> 2200 conditional = ???*0* +2392 -> 2409 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2200 -> 2202 member call = ???*0*["charCodeAt"](???*1*) +2409 -> 2411 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2200 -> 2203 conditional = (???*0* === 44) +2409 -> 2412 conditional = (???*0* === 44) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2203 -> 2204 conditional = ((0 | ???*0*) === 0) +2412 -> 2413 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2204 -> 2205 call = (...) => (undefined | FreeVar(undefined))( +2413 -> 2414 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ",", "ignoreCase": false} ) -2200 -> 2206 conditional = ((???*0* | "," | {}) !== {}) +2409 -> 2415 conditional = ((???*0* | "," | {}) !== {}) - *0* s5 ⚠️ pattern without value -2206 -> 2207 call = (...) => s0() +2415 -> 2416 call = (...) => s0() -2206 -> 2208 conditional = ((???*0* | []) !== {}) +2415 -> 2417 conditional = ((???*0* | []) !== {}) - *0* s6 ⚠️ pattern without value -2208 -> 2209 call = (...) => s0() +2417 -> 2418 call = (...) => s0() -2208 -> 2210 conditional = ???*0* +2417 -> 2419 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2210 -> 2211 call = (...) => v(???*0*, ???*1*) +2419 -> 2420 call = (...) => v(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2183 -> 2212 conditional = ((???*0* | []) !== {}) +2392 -> 2421 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2212 -> 2213 call = (...) => (head ? ???*0* : [])(???*1*, (???*2* | [])) +2421 -> 2422 call = (...) => (head ? ???*0* : [])(???*1*, (???*2* | [])) - *0* spread is not supported ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -7998,77 +8829,85 @@ - *2* s2 ⚠️ pattern without value -0 -> 2215 member call = ???*0*["charCodeAt"](???*1*) +0 -> 2423 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2425 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2216 conditional = (???*0* === 40) +0 -> 2426 conditional = (???*0* === 40) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2216 -> 2217 conditional = ((0 | ???*0*) === 0) +2426 -> 2427 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2217 -> 2218 call = (...) => (undefined | FreeVar(undefined))( +2427 -> 2428 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": "(", "ignoreCase": false} ) -0 -> 2219 conditional = ???*0* +0 -> 2429 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2219 -> 2220 call = (...) => s0() +2429 -> 2430 call = (...) => s0() -2219 -> 2221 conditional = ((???*0* | []) !== {}) +2429 -> 2431 conditional = ((???*0* | []) !== {}) - *0* s2 ⚠️ pattern without value -2221 -> 2222 call = (...) => s0() +2431 -> 2432 call = (...) => s0() -2221 -> 2223 conditional = ???*0* +2431 -> 2433 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2223 -> 2224 call = (...) => s0() +2433 -> 2434 call = (...) => s0() -2223 -> 2225 conditional = ((???*0* | []) !== {}) +2433 -> 2435 conditional = ((???*0* | []) !== {}) - *0* s4 ⚠️ pattern without value -2225 -> 2227 member call = ???*0*["charCodeAt"](???*1*) +2435 -> 2437 member call = ???*0*["charCodeAt"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2225 -> 2228 conditional = (???*0* === 41) +2435 -> 2438 conditional = (???*0* === 41) - *0* ???*1*["charCodeAt"](peg$currPos) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -2228 -> 2229 conditional = ((0 | ???*0*) === 0) +2438 -> 2439 conditional = ((0 | ???*0*) === 0) - *0* updated with update expression ⚠️ This value might have side effects -2229 -> 2230 call = (...) => (undefined | FreeVar(undefined))( +2439 -> 2440 call = (...) => (undefined | FreeVar(undefined))( {"type": "literal", "text": ")", "ignoreCase": false} ) -2225 -> 2231 conditional = ((???*0* | ")" | {}) !== {}) +2435 -> 2441 conditional = ((???*0* | ")" | {}) !== {}) - *0* s5 ⚠️ pattern without value -2231 -> 2232 call = (...) => subquery(???*0*) +2441 -> 2442 call = (...) => subquery(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2234 member call = ???*0*["reduce"]( +0 -> 2443 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2445 member call = ???*0*["reduce"]( (...) => {"type": "scalar_binary_expression", "left": left, "operator": operator, "right": right}, ???*1* ) @@ -8077,61 +8916,6 @@ - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2235 call = ((...) => s0 | ???*0*)() -- *0* {}[???*1*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *1* ???*2*["startRule"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 2237 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -2237 -> 2239 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -2239 -> 2240 call = (...) => {"type": "end"}() - -2239 -> 2241 call = (...) => (undefined | FreeVar(undefined))({"type": "end"}) - -2237 -> 2244 member call = ???*0*["charAt"](???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -2237 -> 2246 call = (...) => { - "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, - "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} -}(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -2237 -> 2247 call = (...) => { - "start": {"offset": startPos, "line": startPosDetails["line"], "column": startPosDetails["column"]}, - "end": {"offset": endPos, "line": endPosDetails["line"], "column": endPosDetails["column"]} -}(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -2237 -> 2248 call = (...) => ???*0*([], (???*1* ? ???*2* : null), ???*4*) -- *0* unknown new expression - ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* ???*3*["charAt"](peg$maxFailPos) - ⚠️ unknown callee object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* max number of linking steps reached +0 -> 2446 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects - -0 -> 2250 free var = FreeVar(module) diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/react-dom-production/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/react-dom-production/resolved-effects.snapshot index 5249bbba89507..8597224d011ed 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/react-dom-production/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/react-dom-production/resolved-effects.snapshot @@ -1,1233 +1,3139 @@ -0 -> 1 free var = FreeVar(require) - -0 -> 2 call = require*0*("react") -- *0* require: The require method from CommonJS - -0 -> 3 free var = FreeVar(require) - -0 -> 4 call = require*0*("scheduler") -- *0* require: The require method from CommonJS - -0 -> 6 free var = FreeVar(arguments) - -0 -> 7 free var = FreeVar(encodeURIComponent) - -0 -> 9 free var = FreeVar(arguments) +0 -> 6 conditional = ???*0* +- *0* ???*1*["isDehydrated"] + ⚠️ unknown object +- *1* ???*2*["memoizedState"] + ⚠️ unknown object +- *2* ???*3*["current"] + ⚠️ unknown object +- *3* ???*4*["stateNode"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 10 call = ???*0*(???*1*) -- *0* FreeVar(encodeURIComponent) - ⚠️ unknown global +6 -> 8 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)(???*1*) +- *0* unsupported expression ⚠️ This value might have side effects -- *1* ???*2*[c] +- *1* ???*2*["pendingLanes"] ⚠️ unknown object - ⚠️ This value might have side effects -- *2* FreeVar(arguments) - ⚠️ unknown global - ⚠️ This value might have side effects - -0 -> 11 free var = FreeVar(Set) - -0 -> 12 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] +- *2* ???*3*["stateNode"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 13 call = (...) => undefined(`${???*0*}Capture`, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] +6 -> 9 call = (...) => undefined(???*0*, ???*2*) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 18 member call = ???*0*["add"](???*1*) -- *0* unknown new expression +- *2* unsupported expression ⚠️ This value might have side effects -- *1* ???*2*[a] + +6 -> 10 call = module["unstable_now"]() + +6 -> 11 call = (...) => undefined(???*0*, module["unstable_now"]()) +- *0* ???*1*["stateNode"] ⚠️ unknown object -- *2* arguments[1] +- *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 19 free var = FreeVar(window) +6 -> 12 call = module["unstable_now"]() -0 -> 21 free var = FreeVar(window) +6 -> 13 call = (...) => null() -0 -> 24 free var = FreeVar(window) +0 -> 14 call = (...) => (undefined | a())((...) => undefined) -0 -> 27 free var = FreeVar(Object) +14 -> 15 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, 1) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 29 member call = ???*0*["call"]({}, ???*3*) -- *0* ???*1*["hasOwnProperty"] +14 -> 16 conditional = (null !== ???*0*) +- *0* (???*1* ? ???*5* : null) + ⚠️ nested operation +- *1* (3 === ???*2*) + ⚠️ nested operation +- *2* ???*3*["tag"] ⚠️ unknown object - ⚠️ This value might have side effects -- *1* ???*2*["prototype"] +- *3* ???*4*["alternate"] ⚠️ unknown object - ⚠️ This value might have side effects -- *2* FreeVar(Object) - ⚠️ unknown global - ⚠️ This value might have side effects -- *3* arguments[0] +- *4* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 31 member call = ???*0*["call"]({}, ???*3*) -- *0* ???*1*["hasOwnProperty"] +- *5* ???*6*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *1* ???*2*["prototype"] +- *6* ???*7*["alternate"] ⚠️ unknown object - ⚠️ This value might have side effects -- *2* FreeVar(Object) - ⚠️ unknown global - ⚠️ This value might have side effects -- *3* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 33 member call = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/["test"](???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 34 conditional = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/["test"](???*0*) -- *0* arguments[0] +- *7* arguments[0] ⚠️ function calls are not analysed yet -0 -> 38 conditional = (null !== ???*0*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet +16 -> 17 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* unsupported expression + ⚠️ This value might have side effects -0 -> 42 member call = (???*0* | ???*1*)["toLowerCase"]() -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*(0, 5) - ⚠️ unknown callee -- *2* ???*3*["slice"] - ⚠️ unknown object -- *3* ???*4*() +16 -> 18 call = (...) => undefined((???*0* ? ???*4* : null), ???*7*, 1, (???*8* ? ???*10* : ???*11*)) +- *0* (3 === ???*1*) ⚠️ nested operation -- *4* ???*5*["toLowerCase"] +- *1* ???*2*["tag"] ⚠️ unknown object -- *5* a - ⚠️ circular variable reference - -0 -> 43 member call = ???*0*()["slice"](0, 5) -- *0* ???*1*["toLowerCase"] +- *2* ???*3*["alternate"] ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 44 call = (...) => (undefined | !(1) | !(0) | !(c["acceptsBooleans"]) | (("data-" !== a) && ("aria-" !== a)))(???*0*, ???*1*, ???*2*, ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *3* arguments[3] +- *4* ???*5*["stateNode"] + ⚠️ unknown object +- *5* ???*6*["alternate"] + ⚠️ unknown object +- *6* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 45 conditional = (null !== ???*0*) -- *0* arguments[2] +- *7* arguments[0] ⚠️ function calls are not analysed yet - -45 -> 47 free var = FreeVar(isNaN) - -45 -> 48 call = ???*0*(???*1*) -- *0* FreeVar(isNaN) - ⚠️ unknown global +- *8* (0 !== ???*9*) + ⚠️ nested operation +- *9* unsupported expression ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet - -45 -> 49 free var = FreeVar(isNaN) - -45 -> 50 call = ???*0*(???*1*) -- *0* FreeVar(isNaN) - ⚠️ unknown global +- *10* module["unstable_now"]() + ⚠️ nested operation +- *11* (???*12* ? (???*16* | ???*17*) : ???*18*) + ⚠️ nested operation +- *12* (???*13* !== (???*14* | ???*15*)) + ⚠️ nested operation +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* unsupported expression + ⚠️ This value might have side effects +- *15* module["unstable_now"]() + ⚠️ nested operation +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* module["unstable_now"]() + ⚠️ nested operation +- *18* unsupported expression ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 61 member call = "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"["split"](" ") - -0 -> 62 member call = "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"["split"](" ")["forEach"]((...) => undefined) - -0 -> 65 member call = [ - ["acceptCharset", "accept-charset"], - ["className", "class"], - ["htmlFor", "for"], - ["httpEquiv", "http-equiv"] -]["forEach"]((...) => undefined) - -0 -> 70 member call = ["contentEditable", "draggable", "spellCheck", "value"]["forEach"]((...) => undefined) -70 -> 73 member call = ???*0*["toLowerCase"]() +0 -> 19 call = (...) => undefined(???*0*, 1) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 75 member call = ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"]["forEach"]((...) => undefined) - -0 -> 79 member call = "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope"["split"](" ") - -0 -> 80 member call = "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope"["split"](" ")["forEach"]((...) => undefined) - -80 -> 83 member call = ???*0*["toLowerCase"]() -- *0* arguments[0] +0 -> 21 conditional = (13 === ???*0*) +- *0* ???*1*["tag"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 85 member call = ["checked", "multiple", "muted", "selected"]["forEach"]((...) => undefined) - -0 -> 88 member call = ["capture", "download"]["forEach"]((...) => undefined) - -0 -> 91 member call = ["cols", "rows", "size", "span"]["forEach"]((...) => undefined) - -0 -> 94 member call = ["rowSpan", "start"]["forEach"]((...) => undefined) - -94 -> 97 member call = ???*0*["toLowerCase"]() +21 -> 22 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, 134217728) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 100 member call = ???*0*["toUpperCase"]() -- *0* ???*1*[1] +21 -> 23 conditional = (null !== ???*0*) +- *0* (???*1* ? ???*5* : null) + ⚠️ nested operation +- *1* (3 === ???*2*) + ⚠️ nested operation +- *2* ???*3*["tag"] ⚠️ unknown object -- *1* arguments[0] +- *3* ???*4*["alternate"] + ⚠️ unknown object +- *4* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 103 member call = "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height"["split"](" ") - -0 -> 104 member call = "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height"["split"](" ")["forEach"]((...) => undefined) - -104 -> 106 member call = ???*0*["replace"](/[\-:]([a-z])/g, (...) => a[1]["toUpperCase"]()) -- *0* arguments[0] +- *5* ???*6*["stateNode"] + ⚠️ unknown object +- *6* ???*7*["alternate"] + ⚠️ unknown object +- *7* arguments[0] ⚠️ function calls are not analysed yet -0 -> 110 member call = "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type"["split"](" ") - -0 -> 111 member call = "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type"["split"](" ")["forEach"]((...) => undefined) +23 -> 24 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* unsupported expression + ⚠️ This value might have side effects -111 -> 113 member call = ???*0*["replace"](/[\-:]([a-z])/g, (...) => a[1]["toUpperCase"]()) -- *0* arguments[0] +23 -> 25 call = (...) => undefined((???*0* ? ???*4* : null), ???*7*, 134217728, (???*8* ? ???*10* : ???*11*)) +- *0* (3 === ???*1*) + ⚠️ nested operation +- *1* ???*2*["tag"] + ⚠️ unknown object +- *2* ???*3*["alternate"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 116 member call = ["xml:base", "xml:lang", "xml:space"]["forEach"]((...) => undefined) - -116 -> 118 member call = ???*0*["replace"](/[\-:]([a-z])/g, (...) => a[1]["toUpperCase"]()) -- *0* arguments[0] +- *4* ???*5*["stateNode"] + ⚠️ unknown object +- *5* ???*6*["alternate"] + ⚠️ unknown object +- *6* arguments[0] ⚠️ function calls are not analysed yet +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* (0 !== ???*9*) + ⚠️ nested operation +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* module["unstable_now"]() + ⚠️ nested operation +- *11* (???*12* ? (???*16* | ???*17*) : ???*18*) + ⚠️ nested operation +- *12* (???*13* !== (???*14* | ???*15*)) + ⚠️ nested operation +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* unsupported expression + ⚠️ This value might have side effects +- *15* module["unstable_now"]() + ⚠️ nested operation +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* module["unstable_now"]() + ⚠️ nested operation +- *18* unsupported expression + ⚠️ This value might have side effects -0 -> 121 member call = ["tabIndex", "crossOrigin"]["forEach"]((...) => undefined) - -121 -> 124 member call = ???*0*["toLowerCase"]() +21 -> 26 call = (...) => undefined(???*0*, 134217728) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 127 member call = ["src", "href", "action", "formAction"]["forEach"]((...) => undefined) +0 -> 28 conditional = (13 === ???*0*) +- *0* ???*1*["tag"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet -127 -> 130 member call = ???*0*["toLowerCase"]() -- *0* arguments[0] +28 -> 29 call = (...) => (1 | ???*0* | ???*1* | a)(???*2*) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 132 member call = {}["hasOwnProperty"]( - (???*0* | (???*1* ? ???*5* : null)["attributeName"] | ???*7*) +28 -> 30 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)( + ???*0*, + ( + | 1 + | ???*1* + | ???*2* + | ???*3* + | 0 + | ???*4* + | 4 + | ((???*5* | ???*7*) ? ???*8* : 4) + | (???*9* ? 16 : (???*10* | null | ???*17* | ???*18*)) + | ???*20* + | (???*22* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ) ) -- *0* arguments[1] +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* (???*2* | ???*3*)(???*4*) - ⚠️ non-function callee -- *2* FreeVar(undefined) - ⚠️ unknown global +- *1* unsupported expression ⚠️ This value might have side effects -- *3* unknown mutation +- *2* Ck + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *4* b +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* C ⚠️ circular variable reference -- *5* {}[???*6*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *6* b +- *5* (0 !== ???*6*) + ⚠️ nested operation +- *6* C ⚠️ circular variable reference -- *7* ???*8*["attributeName"] - ⚠️ unknown object -- *8* ???*9*["type"] - ⚠️ unknown object -- *9* e +- *7* unsupported expression + ⚠️ This value might have side effects +- *8* C ⚠️ circular variable reference - -0 -> 133 conditional = ???*0* -- *0* (???*1* | ???*2*)( - (???*3* | (???*4* ? ???*8* : null)["attributeName"] | ???*10*) - ) - ⚠️ non-function callee +- *9* unsupported expression ⚠️ This value might have side effects -- *1* FreeVar(undefined) - ⚠️ unknown global +- *10* (???*11* ? ???*12* : 1) + ⚠️ nested operation +- *11* unsupported expression ⚠️ This value might have side effects -- *2* unknown mutation +- *12* (???*13* ? ???*14* : 4) + ⚠️ nested operation +- *13* unsupported expression ⚠️ This value might have side effects -- *3* arguments[1] +- *14* (???*15* ? 16 : 536870912) + ⚠️ nested operation +- *15* (0 !== ???*16*) + ⚠️ nested operation +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* arguments[0] ⚠️ function calls are not analysed yet -- *4* (???*5* | ???*6*)(???*7*) - ⚠️ non-function callee -- *5* FreeVar(undefined) - ⚠️ unknown global +- *18* ???*19*["value"] + ⚠️ unknown object +- *19* arguments[1] + ⚠️ function calls are not analysed yet +- *20* ???*21*["event"] + ⚠️ unknown object ⚠️ This value might have side effects -- *6* unknown mutation +- *21* FreeVar(window) + ⚠️ unknown global ⚠️ This value might have side effects -- *7* b - ⚠️ circular variable reference -- *8* {}[???*9*] - ⚠️ unknown object prototype methods or values +- *22* (???*23* === ???*24*) + ⚠️ nested operation +- *23* unsupported expression ⚠️ This value might have side effects -- *9* b - ⚠️ circular variable reference -- *10* ???*11*["attributeName"] - ⚠️ unknown object -- *11* ???*12*["type"] - ⚠️ unknown object -- *12* e +- *24* a ⚠️ circular variable reference -0 -> 135 conditional = (null !== (???*0* | ???*9*)) -- *0* (???*1* ? ???*7* : null) +28 -> 31 conditional = (null !== ???*0*) +- *0* (???*1* ? ???*5* : null) ⚠️ nested operation -- *1* (???*2* | ???*3*)((???*4* | ???*5*)) - ⚠️ non-function callee -- *2* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *3* unknown mutation - ⚠️ This value might have side effects -- *4* arguments[1] - ⚠️ function calls are not analysed yet -- *5* ???*6*["attributeName"] +- *1* (3 === ???*2*) + ⚠️ nested operation +- *2* ???*3*["tag"] ⚠️ unknown object -- *6* e - ⚠️ circular variable reference -- *7* {}[???*8*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *8* arguments[1] +- *3* ???*4*["alternate"] + ⚠️ unknown object +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *9* ???*10*["type"] +- *5* ???*6*["stateNode"] ⚠️ unknown object -- *10* e - ⚠️ circular variable reference +- *6* ???*7*["alternate"] + ⚠️ unknown object +- *7* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 142 conditional = (???*0* ? ???*12* : (???*22* | ???*23* | ???*33*)) -- *0* (null !== (???*1* | ???*10*)) - ⚠️ nested operation -- *1* (???*2* ? ???*8* : null) - ⚠️ nested operation -- *2* (???*3* | ???*4*)((???*5* | ???*6*)) - ⚠️ non-function callee -- *3* FreeVar(undefined) - ⚠️ unknown global +31 -> 32 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression ⚠️ This value might have side effects -- *4* unknown mutation +- *1* unsupported expression ⚠️ This value might have side effects -- *5* arguments[1] +- *2* unsupported expression + ⚠️ This value might have side effects + +31 -> 33 call = (...) => undefined( + (???*0* ? ???*4* : null), + ???*7*, + ( + | 1 + | ???*8* + | ???*9* + | ???*10* + | 0 + | ???*11* + | 4 + | ((???*12* | ???*14*) ? ???*15* : 4) + | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) + | ???*27* + | (???*29* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + (???*32* ? ???*34* : ???*35*) +) +- *0* (3 === ???*1*) + ⚠️ nested operation +- *1* ???*2*["tag"] + ⚠️ unknown object +- *2* ???*3*["alternate"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *6* ???*7*["attributeName"] +- *4* ???*5*["stateNode"] ⚠️ unknown object -- *7* e - ⚠️ circular variable reference -- *8* {}[???*9*] - ⚠️ unknown object prototype methods or values +- *5* ???*6*["alternate"] + ⚠️ unknown object +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* unsupported expression ⚠️ This value might have side effects -- *9* arguments[1] +- *9* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *10* arguments[0] ⚠️ function calls are not analysed yet -- *10* ???*11*["type"] - ⚠️ unknown object -- *11* e +- *11* C ⚠️ circular variable reference - *12* (0 !== ???*13*) ⚠️ nested operation -- *13* ???*14*["type"] - ⚠️ unknown object -- *14* (???*15* ? ???*20* : null) +- *13* C + ⚠️ circular variable reference +- *14* unsupported expression + ⚠️ This value might have side effects +- *15* C + ⚠️ circular variable reference +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* (???*18* ? ???*19* : 1) ⚠️ nested operation -- *15* (???*16* | ???*17*)((???*18* | ???*19*)) - ⚠️ non-function callee -- *16* FreeVar(undefined) - ⚠️ unknown global +- *18* unsupported expression ⚠️ This value might have side effects -- *17* unknown mutation +- *19* (???*20* ? ???*21* : 4) + ⚠️ nested operation +- *20* unsupported expression ⚠️ This value might have side effects -- *18* arguments[1] - ⚠️ function calls are not analysed yet -- *19* ???["attributeName"] - ⚠️ unknown object -- *20* {}[???*21*] - ⚠️ unknown object prototype methods or values +- *21* (???*22* ? 16 : 536870912) + ⚠️ nested operation +- *22* (0 !== ???*23*) + ⚠️ nested operation +- *23* unsupported expression ⚠️ This value might have side effects -- *21* arguments[1] +- *24* arguments[0] ⚠️ function calls are not analysed yet -- *22* arguments[3] +- *25* ???*26*["value"] + ⚠️ unknown object +- *26* arguments[1] ⚠️ function calls are not analysed yet -- *23* ???*24*["attributeNamespace"] +- *27* ???*28*["event"] ⚠️ unknown object -- *24* (???*25* ? ???*31* : null) - ⚠️ nested operation -- *25* (???*26* | ???*27*)((???*28* | ???*29*)) - ⚠️ non-function callee -- *26* FreeVar(undefined) + ⚠️ This value might have side effects +- *28* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *27* unknown mutation +- *29* (???*30* === ???*31*) + ⚠️ nested operation +- *30* unsupported expression ⚠️ This value might have side effects -- *28* arguments[1] - ⚠️ function calls are not analysed yet -- *29* ???*30*["attributeName"] - ⚠️ unknown object -- *30* e +- *31* a ⚠️ circular variable reference -- *31* {}[???*32*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *32* arguments[1] - ⚠️ function calls are not analysed yet -- *33* !(???*34*) +- *32* (0 !== ???*33*) ⚠️ nested operation -- *34* unsupported expression +- *33* unsupported expression ⚠️ This value might have side effects - -142 -> 143 call = (...) => (!(0) | !(1) | !(b) | (!(1) === b) | FreeVar(isNaN)(b) | (FreeVar(isNaN)(b) || ???*0*))( - (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*), - (???*11* | null | (???*12* ? "" : ???*24*)), - ((???*25* ? ???*31* : null) | ???*33*), - (???*35* | (???*36* ? ???*42* : null)["attributeNamespace"] | ???*44*) -) -- *0* unsupported expression +- *34* module["unstable_now"]() + ⚠️ nested operation +- *35* (???*36* ? (???*40* | ???*41*) : ???*42*) + ⚠️ nested operation +- *36* (???*37* !== (???*38* | ???*39*)) + ⚠️ nested operation +- *37* unsupported expression ⚠️ This value might have side effects -- *1* arguments[1] +- *38* unsupported expression + ⚠️ This value might have side effects +- *39* module["unstable_now"]() + ⚠️ nested operation +- *40* unsupported expression + ⚠️ This value might have side effects +- *41* module["unstable_now"]() + ⚠️ nested operation +- *42* unsupported expression + ⚠️ This value might have side effects + +28 -> 34 call = (...) => undefined( + ???*0*, + ( + | 1 + | ???*1* + | ???*2* + | ???*3* + | 0 + | ???*4* + | 4 + | ((???*5* | ???*7*) ? ???*8* : 4) + | (???*9* ? 16 : (???*10* | null | ???*17* | ???*18*)) + | ???*20* + | (???*22* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ) +) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)(???*5*) - ⚠️ non-function callee -- *3* FreeVar(undefined) - ⚠️ unknown global +- *1* unsupported expression ⚠️ This value might have side effects -- *4* unknown mutation +- *2* Ck + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *5* b +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* C ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *7* b +- *5* (0 !== ???*6*) + ⚠️ nested operation +- *6* C ⚠️ circular variable reference -- *8* ???*9*["attributeName"] - ⚠️ unknown object -- *9* ???*10*["type"] - ⚠️ unknown object -- *10* e +- *7* unsupported expression + ⚠️ This value might have side effects +- *8* C ⚠️ circular variable reference -- *11* arguments[2] - ⚠️ function calls are not analysed yet -- *12* (3 === (???*13* | ???*22*)) +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* (???*11* ? ???*12* : 1) ⚠️ nested operation -- *13* (???*14* ? ???*20* : null) +- *11* unsupported expression + ⚠️ This value might have side effects +- *12* (???*13* ? ???*14* : 4) ⚠️ nested operation -- *14* (???*15* | ???*16*)((???*17* | ???*18*)) - ⚠️ non-function callee -- *15* FreeVar(undefined) - ⚠️ unknown global +- *13* unsupported expression ⚠️ This value might have side effects -- *16* unknown mutation +- *14* (???*15* ? 16 : 536870912) + ⚠️ nested operation +- *15* (0 !== ???*16*) + ⚠️ nested operation +- *16* unsupported expression ⚠️ This value might have side effects -- *17* arguments[1] +- *17* arguments[0] ⚠️ function calls are not analysed yet -- *18* ???*19*["attributeName"] +- *18* ???*19*["value"] ⚠️ unknown object -- *19* e - ⚠️ circular variable reference -- *20* {}[???*21*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *21* arguments[1] +- *19* arguments[1] ⚠️ function calls are not analysed yet -- *22* ???*23*["type"] +- *20* ???*21*["event"] ⚠️ unknown object -- *23* e - ⚠️ circular variable reference -- *24* c - ⚠️ circular variable reference -- *25* (???*26* | ???*27*)((???*28* | ???*29*)) - ⚠️ non-function callee -- *26* FreeVar(undefined) + ⚠️ This value might have side effects +- *21* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *27* unknown mutation +- *22* (???*23* === ???*24*) + ⚠️ nested operation +- *23* unsupported expression ⚠️ This value might have side effects -- *28* arguments[1] - ⚠️ function calls are not analysed yet -- *29* ???*30*["attributeName"] - ⚠️ unknown object -- *30* e +- *24* a ⚠️ circular variable reference -- *31* {}[???*32*] - ⚠️ unknown object prototype methods or values + +0 -> 35 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *32* arguments[1] + +0 -> 36 call = ???*0*() +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *33* ???*34*["type"] + +0 -> 37 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 38 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*1* | ???*2* | ???*4*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* ???*3*["parentNode"] ⚠️ unknown object -- *34* e +- *3* c ⚠️ circular variable reference -- *35* arguments[3] +- *4* ???*5*["querySelectorAll"]( + `input[name=${FreeVar(JSON)["stringify"](`${b}`)}][type="radio"]` + ) + ⚠️ unknown callee object +- *5* c + ⚠️ circular variable reference + +0 -> 41 conditional = (("radio" === ???*0*) | (null != (???*2* | ???*3* | 0 | ???*5*))) +- *0* ???*1*["type"] + ⚠️ unknown object +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *36* (???*37* | ???*38*)((???*39* | ???*40*)) - ⚠️ non-function callee -- *37* FreeVar(undefined) - ⚠️ unknown global +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* ???*4*["name"] + ⚠️ unknown object +- *4* arguments[2] + ⚠️ function calls are not analysed yet +- *5* updated with update expression ⚠️ This value might have side effects -- *38* unknown mutation + +41 -> 46 free var = FreeVar(JSON) + +41 -> 47 member call = ???*0*["stringify"]((???*1* | ???*2* | 0 | ???*4*)) +- *0* FreeVar(JSON) + ⚠️ unknown global ⚠️ This value might have side effects -- *39* arguments[1] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *40* ???*41*["attributeName"] +- *2* ???*3*["name"] ⚠️ unknown object -- *41* e - ⚠️ circular variable reference -- *42* {}[???*43*] - ⚠️ unknown object prototype methods or values +- *3* arguments[2] + ⚠️ function calls are not analysed yet +- *4* updated with update expression ⚠️ This value might have side effects -- *43* arguments[1] + +41 -> 48 member call = (???*0* | ???*1* | ???*3*)["querySelectorAll"](`input[name=${???*5*}][type="radio"]`) +- *0* arguments[2] ⚠️ function calls are not analysed yet -- *44* ???*45*["attributeNamespace"] - ⚠️ unknown object -- *45* ???*46*["type"] +- *1* ???*2*["parentNode"] ⚠️ unknown object -- *46* e +- *2* c ⚠️ circular variable reference - -142 -> 144 conditional = (???*0* | (???*1* ? ???*7* : null)["attributeNamespace"] | ???*9* | (null === (???*12* | ???*21*))) -- *0* arguments[3] - ⚠️ function calls are not analysed yet -- *1* (???*2* | ???*3*)((???*4* | ???*5*)) - ⚠️ non-function callee -- *2* FreeVar(undefined) +- *3* ???*4*["querySelectorAll"]( + `input[name=${FreeVar(JSON)["stringify"](`${b}`)}][type="radio"]` + ) + ⚠️ unknown callee object +- *4* c + ⚠️ circular variable reference +- *5* ???*6*["stringify"](b) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *6* FreeVar(JSON) ⚠️ unknown global ⚠️ This value might have side effects -- *3* unknown mutation + +41 -> 53 conditional = ((???*0* !== ???*6*) | (???*7* === ???*14*)) +- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] + ⚠️ unknown object ⚠️ This value might have side effects -- *4* arguments[1] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *5* ???*6*["attributeName"] +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* ???*4*["name"] ⚠️ unknown object -- *6* e - ⚠️ circular variable reference -- *7* {}[???*8*] - ⚠️ unknown object prototype methods or values +- *4* arguments[2] + ⚠️ function calls are not analysed yet +- *5* updated with update expression ⚠️ This value might have side effects -- *8* arguments[1] +- *6* arguments[0] ⚠️ function calls are not analysed yet -- *9* ???*10*["attributeNamespace"] - ⚠️ unknown object -- *10* ???*11*["type"] +- *7* ???*8*["form"] ⚠️ unknown object -- *11* e - ⚠️ circular variable reference -- *12* (???*13* ? ???*19* : null) - ⚠️ nested operation -- *13* (???*14* | ???*15*)((???*16* | ???*17*)) - ⚠️ non-function callee -- *14* FreeVar(undefined) - ⚠️ unknown global ⚠️ This value might have side effects -- *15* unknown mutation +- *8* ???*9*[(???*10* | ???*11* | 0 | ???*13*)] + ⚠️ unknown object ⚠️ This value might have side effects -- *16* arguments[1] +- *9* arguments[2] ⚠️ function calls are not analysed yet -- *17* ???*18*["attributeName"] +- *10* arguments[1] + ⚠️ function calls are not analysed yet +- *11* ???*12*["name"] ⚠️ unknown object -- *18* e - ⚠️ circular variable reference -- *19* {}[???*20*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *20* arguments[1] +- *12* arguments[2] ⚠️ function calls are not analysed yet -- *21* ???*22*["type"] +- *13* updated with update expression + ⚠️ This value might have side effects +- *14* ???*15*["form"] ⚠️ unknown object -- *22* e - ⚠️ circular variable reference +- *15* arguments[0] + ⚠️ function calls are not analysed yet -144 -> 145 call = (...) => (!(0) | !(1) | ???*0*)( - (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*) -) -- *0* unsupported expression +53 -> 54 call = (...) => (a[Pf] || null)(???*0*) +- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* arguments[1] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)(???*5*) - ⚠️ non-function callee -- *3* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *4* unknown mutation - ⚠️ This value might have side effects -- *5* b - ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *7* b - ⚠️ circular variable reference -- *8* ???*9*["attributeName"] - ⚠️ unknown object -- *9* ???*10*["type"] +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* ???*4*["name"] ⚠️ unknown object -- *10* e - ⚠️ circular variable reference - -144 -> 146 conditional = (null === (???*0* | null | ???*1*)) -- *0* arguments[2] +- *4* arguments[2] ⚠️ function calls are not analysed yet -- *1* (???*2* ? "" : ???*13*) - ⚠️ nested operation -- *2* (3 === (???*3* | ???*11*)) - ⚠️ nested operation -- *3* (???*4* ? ???*9* : null) - ⚠️ nested operation -- *4* (???*5* | ???*6*)((???*7* | ???*8*)) - ⚠️ non-function callee -- *5* FreeVar(undefined) - ⚠️ unknown global +- *5* updated with update expression ⚠️ This value might have side effects -- *6* unknown mutation + +53 -> 55 conditional = !((???*0* | null)) +- *0* ???*1*[Pf] + ⚠️ unknown object ⚠️ This value might have side effects -- *7* arguments[1] - ⚠️ function calls are not analysed yet -- *8* ???["attributeName"] +- *1* ???*2*[(???*3* | ???*4* | 0 | ???*6*)] ⚠️ unknown object -- *9* {}[???*10*] - ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects -- *10* arguments[1] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *11* ???*12*["type"] +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* ???*5*["name"] ⚠️ unknown object -- *12* e - ⚠️ circular variable reference -- *13* c - ⚠️ circular variable reference +- *5* arguments[2] + ⚠️ function calls are not analysed yet +- *6* updated with update expression + ⚠️ This value might have side effects -146 -> 148 member call = ???*0*["removeAttribute"]( - (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*) +55 -> 56 free var = FreeVar(Error) + +55 -> 57 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(90) + +55 -> 58 call = ???*0*( + `Minified React error #${90}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)(???*5*) - ⚠️ non-function callee -- *3* FreeVar(undefined) +- *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *4* unknown mutation - ⚠️ This value might have side effects -- *5* b - ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *7* b - ⚠️ circular variable reference -- *8* ???*9*["attributeName"] +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${90}` + ⚠️ nested operation + +53 -> 59 call = (...) => (!(1) | !(0) | ((a !== c) ? !(0) : !(1)))(???*0*) +- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] ⚠️ unknown object -- *9* ???*10*["type"] + ⚠️ This value might have side effects +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* ???*4*["name"] ⚠️ unknown object -- *10* e - ⚠️ circular variable reference +- *4* arguments[2] + ⚠️ function calls are not analysed yet +- *5* updated with update expression + ⚠️ This value might have side effects -146 -> 150 member call = ???*0*["setAttribute"]( - (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*), - (???*11* | null | (???*12* ? "" : ???*24*)) -) -- *0* arguments[0] +53 -> 60 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*6* | null)) +- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *1* arguments[1] +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)(???*5*) - ⚠️ non-function callee -- *3* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *4* unknown mutation +- *3* ???*4*["name"] + ⚠️ unknown object +- *4* arguments[2] + ⚠️ function calls are not analysed yet +- *5* updated with update expression ⚠️ This value might have side effects -- *5* b - ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values +- *6* ???*7*[Pf] + ⚠️ unknown object ⚠️ This value might have side effects -- *7* b - ⚠️ circular variable reference -- *8* ???*9*["attributeName"] +- *7* ???*8*[(???*9* | ???*10* | 0 | ???*12*)] ⚠️ unknown object -- *9* ???*10*["type"] + ⚠️ This value might have side effects +- *8* arguments[2] + ⚠️ function calls are not analysed yet +- *9* arguments[1] + ⚠️ function calls are not analysed yet +- *10* ???*11*["name"] ⚠️ unknown object -- *10* e - ⚠️ circular variable reference - *11* arguments[2] ⚠️ function calls are not analysed yet -- *12* (3 === (???*13* | ???*22*)) - ⚠️ nested operation -- *13* (???*14* ? ???*20* : null) - ⚠️ nested operation -- *14* (???*15* | ???*16*)((???*17* | ???*18*)) - ⚠️ non-function callee -- *15* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *16* unknown mutation +- *12* updated with update expression ⚠️ This value might have side effects -- *17* arguments[1] + +0 -> 61 call = (...) => undefined(???*0*, (???*1* | ???*2* | ???*4*)) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *18* ???*19*["attributeName"] - ⚠️ unknown object -- *19* e - ⚠️ circular variable reference -- *20* {}[???*21*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *21* arguments[1] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *22* ???*23*["type"] +- *2* ???*3*["parentNode"] ⚠️ unknown object -- *23* e +- *3* c ⚠️ circular variable reference -- *24* c +- *4* ???*5*["querySelectorAll"]( + `input[name=${FreeVar(JSON)["stringify"](`${b}`)}][type="radio"]` + ) + ⚠️ unknown callee object +- *5* c ⚠️ circular variable reference -144 -> 152 conditional = ((???*0* ? ???*6* : null)["mustUseProperty"] | ???*8*) -- *0* (???*1* | ???*2*)((???*3* | ???*4*)) - ⚠️ non-function callee -- *1* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *2* unknown mutation - ⚠️ This value might have side effects -- *3* arguments[1] +0 -> 64 call = (...) => (undefined | FreeVar(undefined))(???*0*, !(???*1*), (???*4* | ???*5* | 0 | ???*7*), false) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["attributeName"] +- *1* !(???*2*) + ⚠️ nested operation +- *2* ???*3*["multiple"] ⚠️ unknown object -- *5* e - ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *7* arguments[1] +- *3* arguments[2] ⚠️ function calls are not analysed yet -- *8* ???*9*["mustUseProperty"] - ⚠️ unknown object -- *9* ???*10*["type"] +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* ???*6*["name"] ⚠️ unknown object -- *10* e - ⚠️ circular variable reference - -152 -> 155 conditional = (null === (???*0* | null | ???*1*)) -- *0* arguments[2] +- *6* arguments[2] ⚠️ function calls are not analysed yet -- *1* (???*2* ? "" : ???*13*) - ⚠️ nested operation -- *2* (3 === (???*3* | ???*11*)) - ⚠️ nested operation -- *3* (???*4* ? ???*9* : null) - ⚠️ nested operation -- *4* (???*5* | ???*6*)((???*7* | ???*8*)) - ⚠️ non-function callee -- *5* FreeVar(undefined) - ⚠️ unknown global +- *7* updated with update expression ⚠️ This value might have side effects -- *6* unknown mutation + +0 -> 70 call = (...) => ((null !== a) ? $b(a) : null)(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *7* arguments[1] - ⚠️ function calls are not analysed yet -- *8* ???["attributeName"] - ⚠️ unknown object -- *9* {}[???*10*] - ⚠️ unknown object prototype methods or values + +0 -> 71 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *10* arguments[1] - ⚠️ function calls are not analysed yet -- *11* ???*12*["type"] - ⚠️ unknown object -- *12* e - ⚠️ circular variable reference -- *13* c - ⚠️ circular variable reference -155 -> 157 conditional = (3 === ???*0*) -- *0* ???*1*["type"] - ⚠️ unknown object -- *1* (???*2* ? ???*8* : null) +0 -> 73 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 75 free var = FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + +0 -> 76 conditional = ("undefined" !== ???*0*) +- *0* typeof(???*1*) ⚠️ nested operation -- *2* (???*3* | ???*4*)((???*5* | ???*6*)) - ⚠️ non-function callee -- *3* FreeVar(undefined) +- *1* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) ⚠️ unknown global ⚠️ This value might have side effects -- *4* unknown mutation + +76 -> 77 free var = FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + +76 -> 80 conditional = (!(???*0*) | ???*2*) +- *0* ???*1*["isDisabled"] + ⚠️ unknown object ⚠️ This value might have side effects -- *5* arguments[1] - ⚠️ function calls are not analysed yet -- *6* ???*7*["attributeName"] - ⚠️ unknown object -- *7* e - ⚠️ circular variable reference -- *8* {}[???*9*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *9* arguments[1] - ⚠️ function calls are not analysed yet - -152 -> 160 conditional = (null === (???*0* | null | ???*1*)) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* (???*2* ? "" : ???*13*) - ⚠️ nested operation -- *2* (3 === (???*3* | ???*11*)) - ⚠️ nested operation -- *3* (???*4* ? ???*9* : null) - ⚠️ nested operation -- *4* (???*5* | ???*6*)((???*7* | ???*8*)) - ⚠️ non-function callee -- *5* FreeVar(undefined) +- *1* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) ⚠️ unknown global ⚠️ This value might have side effects -- *6* unknown mutation - ⚠️ This value might have side effects -- *7* arguments[1] - ⚠️ function calls are not analysed yet -- *8* ???["attributeName"] +- *2* ???*3*["supportsFiber"] ⚠️ unknown object -- *9* {}[???*10*] - ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects -- *10* arguments[1] - ⚠️ function calls are not analysed yet -- *11* ???*12*["type"] - ⚠️ unknown object -- *12* e - ⚠️ circular variable reference -- *13* c - ⚠️ circular variable reference +- *3* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global + ⚠️ This value might have side effects -160 -> 162 member call = ???*0*["removeAttribute"]( - (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*) +80 -> 82 member call = ???*0*["inject"]( + { + "bundleType": (0 | ???*1*), + "version": ("18.2.0" | ???*2*), + "rendererPackageName": ("react-dom" | ???*3*), + "rendererConfig": (???*4* | ???*5*), + "overrideHookState": null, + "overrideHookStateDeletePath": null, + "overrideHookStateRenamePath": null, + "overrideProps": null, + "overridePropsDeletePath": null, + "overridePropsRenamePath": null, + "setErrorHandler": null, + "setSuspenseHandler": null, + "scheduleUpdate": null, + "currentDispatcherRef": module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"], + "findHostInstanceByFiber": (...) => ((null === a) ? null : a["stateNode"]), + "findFiberByHostInstance": ((...) => (b | c | null) | ???*6* | (...) => null){truthy}, + "findHostInstancesForRefresh": null, + "scheduleRefresh": null, + "scheduleRoot": null, + "setRefreshHandler": null, + "getCurrentFiber": null, + "reconcilerVersion": "18.2.0-next-9e3b772b8-20220608" + } ) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)(???*5*) - ⚠️ non-function callee -- *3* FreeVar(undefined) +- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) ⚠️ unknown global ⚠️ This value might have side effects -- *4* unknown mutation - ⚠️ This value might have side effects -- *5* b - ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values +- *1* unknown mutation ⚠️ This value might have side effects -- *7* b - ⚠️ circular variable reference -- *8* ???*9*["attributeName"] - ⚠️ unknown object -- *9* ???*10*["type"] - ⚠️ unknown object -- *10* e - ⚠️ circular variable reference - -160 -> 164 conditional = ((3 === (???*0* | ???*9*)) | (4 === (???*11* | ???*20*)) | (true === (???*22* | null | ???*23*))) -- *0* (???*1* ? ???*7* : null) - ⚠️ nested operation -- *1* (???*2* | ???*3*)((???*4* | ???*5*)) - ⚠️ non-function callee -- *2* FreeVar(undefined) - ⚠️ unknown global +- *2* unknown mutation ⚠️ This value might have side effects - *3* unknown mutation ⚠️ This value might have side effects -- *4* arguments[1] - ⚠️ function calls are not analysed yet -- *5* ???*6*["attributeName"] - ⚠️ unknown object -- *6* e - ⚠️ circular variable reference -- *7* {}[???*8*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *8* arguments[1] - ⚠️ function calls are not analysed yet -- *9* ???*10*["type"] - ⚠️ unknown object -- *10* e - ⚠️ circular variable reference -- *11* (???*12* ? ???*18* : null) - ⚠️ nested operation -- *12* (???*13* | ???*14*)((???*15* | ???*16*)) - ⚠️ non-function callee -- *13* FreeVar(undefined) +- *4* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects -- *14* unknown mutation +- *5* unknown mutation ⚠️ This value might have side effects -- *15* arguments[1] - ⚠️ function calls are not analysed yet -- *16* ???*17*["attributeName"] - ⚠️ unknown object -- *17* e - ⚠️ circular variable reference -- *18* {}[???*19*] - ⚠️ unknown object prototype methods or values +- *6* unknown mutation ⚠️ This value might have side effects -- *19* arguments[1] - ⚠️ function calls are not analysed yet -- *20* ???*21*["type"] - ⚠️ unknown object -- *21* e - ⚠️ circular variable reference -- *22* arguments[2] - ⚠️ function calls are not analysed yet -- *23* (???*24* ? "" : ???*35*) - ⚠️ nested operation -- *24* (3 === (???*25* | ???*33*)) - ⚠️ nested operation -- *25* (???*26* ? ???*31* : null) - ⚠️ nested operation -- *26* (???*27* | ???*28*)((???*29* | ???*30*)) - ⚠️ non-function callee -- *27* FreeVar(undefined) - ⚠️ unknown global + +0 -> 84 free var = FreeVar(exports) + +0 -> 86 free var = FreeVar(exports) + +0 -> 88 free var = FreeVar(arguments) + +0 -> 90 free var = FreeVar(arguments) + +0 -> 91 conditional = (???*0* | (???*1* !== ???*2*)) +- *0* unsupported expression ⚠️ This value might have side effects -- *28* unknown mutation +- *1* unsupported expression ⚠️ This value might have side effects -- *29* arguments[1] - ⚠️ function calls are not analysed yet -- *30* ???["attributeName"] +- *2* ???*3*[2] ⚠️ unknown object -- *31* {}[???*32*] - ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects -- *32* arguments[1] - ⚠️ function calls are not analysed yet -- *33* ???*34*["type"] - ⚠️ unknown object -- *34* e - ⚠️ circular variable reference -- *35* c - ⚠️ circular variable reference - -160 -> 165 conditional = (???*0* | (???*1* ? ???*7* : null)["attributeNamespace"] | ???*9*) -- *0* arguments[3] - ⚠️ function calls are not analysed yet -- *1* (???*2* | ???*3*)((???*4* | ???*5*)) - ⚠️ non-function callee -- *2* FreeVar(undefined) +- *3* FreeVar(arguments) ⚠️ unknown global ⚠️ This value might have side effects -- *3* unknown mutation - ⚠️ This value might have side effects -- *4* arguments[1] + +91 -> 93 free var = FreeVar(arguments) + +0 -> 94 call = (...) => !(( + || !(a) + || ((1 !== a["nodeType"]) && (9 !== a["nodeType"]) && (11 !== a["nodeType"])) +))(???*0*) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *5* ???*6*["attributeName"] - ⚠️ unknown object -- *6* e - ⚠️ circular variable reference -- *7* {}[???*8*] - ⚠️ unknown object prototype methods or values - ⚠️ This value might have side effects -- *8* arguments[1] + +0 -> 95 conditional = !(???*0*) +- *0* !(???*1*) + ⚠️ nested operation +- *1* !(???*2*) + ⚠️ nested operation +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *9* ???*10*["attributeNamespace"] - ⚠️ unknown object -- *10* ???*11*["type"] - ⚠️ unknown object -- *11* e - ⚠️ circular variable reference -165 -> 167 member call = ???*0*["setAttributeNS"]( - (???*1* | (???*2* ? ???*8* : null)["attributeNamespace"] | ???*10*), - (???*13* | (???*14* ? ???*18* : null)["attributeName"] | ???*20*), - (???*23* | null | (???*24* ? "" : ???*36*)) +95 -> 96 free var = FreeVar(Error) + +95 -> 97 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) + +95 -> 98 call = ???*0*( + `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` + ⚠️ nested operation + +0 -> 99 call = (...) => { + "$$typeof": wa, + "key": ((null == d) ? null : `${d}`), + "children": a, + "containerInfo": b, + "implementation": c +}(???*0*, ???*1*, null, ((???*2* | ???*3*) ? ???*7* : null)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[3] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)((???*5* | ???*6*)) - ⚠️ non-function callee -- *3* FreeVar(undefined) - ⚠️ unknown global +- *2* unsupported expression ⚠️ This value might have side effects -- *4* unknown mutation +- *3* (???*4* !== ???*5*) + ⚠️ nested operation +- *4* unsupported expression ⚠️ This value might have side effects -- *5* arguments[1] - ⚠️ function calls are not analysed yet -- *6* ???*7*["attributeName"] +- *5* ???*6*[2] ⚠️ unknown object -- *7* e - ⚠️ circular variable reference -- *8* {}[???*9*] - ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects -- *9* arguments[1] - ⚠️ function calls are not analysed yet -- *10* ???*11*["attributeNamespace"] - ⚠️ unknown object -- *11* ???*12*["type"] - ⚠️ unknown object -- *12* e - ⚠️ circular variable reference -- *13* arguments[1] - ⚠️ function calls are not analysed yet -- *14* (???*15* | ???*16*)(???*17*) - ⚠️ non-function callee -- *15* FreeVar(undefined) +- *6* FreeVar(arguments) ⚠️ unknown global ⚠️ This value might have side effects -- *16* unknown mutation +- *7* ???*8*[2] + ⚠️ unknown object ⚠️ This value might have side effects -- *17* b - ⚠️ circular variable reference -- *18* {}[???*19*] - ⚠️ unknown object prototype methods or values +- *8* FreeVar(arguments) + ⚠️ unknown global ⚠️ This value might have side effects -- *19* b - ⚠️ circular variable reference -- *20* ???*21*["attributeName"] - ⚠️ unknown object -- *21* ???*22*["type"] - ⚠️ unknown object -- *22* e - ⚠️ circular variable reference -- *23* arguments[2] + +0 -> 100 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 102 free var = FreeVar(exports) + +0 -> 103 call = (...) => !(( + || !(a) + || ((1 !== a["nodeType"]) && (9 !== a["nodeType"]) && (11 !== a["nodeType"])) +))(???*0*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *24* (3 === (???*25* | ???*34*)) + +0 -> 104 conditional = !(???*0*) +- *0* !(???*1*) ⚠️ nested operation -- *25* (???*26* ? ???*32* : null) +- *1* !(???*2*) ⚠️ nested operation -- *26* (???*27* | ???*28*)((???*29* | ???*30*)) - ⚠️ non-function callee -- *27* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *28* unknown mutation - ⚠️ This value might have side effects -- *29* arguments[1] +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *30* ???*31*["attributeName"] - ⚠️ unknown object -- *31* e - ⚠️ circular variable reference -- *32* {}[???*33*] - ⚠️ unknown object prototype methods or values + +104 -> 105 free var = FreeVar(Error) + +104 -> 106 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(299) + +104 -> 107 call = ???*0*( + `Minified React error #${299}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *33* arguments[1] - ⚠️ function calls are not analysed yet -- *34* ???*35*["type"] - ⚠️ unknown object -- *35* e - ⚠️ circular variable reference -- *36* c - ⚠️ circular variable reference +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${299}` + ⚠️ nested operation -165 -> 169 member call = ???*0*["setAttribute"]( - (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*), - (???*11* | null | (???*12* ? "" : ???*24*)) +0 -> 113 call = (...) => a( + ???*0*, + 1, + false, + null, + null, + (false | true), + false, + ("" | ???*1* | ???*3*), + ((???*5* ? ???*8* : (...) => undefined) | ???*9* | ???*11*) ) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[1] +- *1* ???*2*["identifierPrefix"] + ⚠️ unknown object +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *2* (???*3* | ???*4*)(???*5*) - ⚠️ non-function callee -- *3* FreeVar(undefined) - ⚠️ unknown global - ⚠️ This value might have side effects -- *4* unknown mutation +- *3* ???*4*["identifierPrefix"] + ⚠️ unknown object ⚠️ This value might have side effects -- *5* b - ⚠️ circular variable reference -- *6* {}[???*7*] - ⚠️ unknown object prototype methods or values +- *4* unknown new expression ⚠️ This value might have side effects -- *7* b - ⚠️ circular variable reference -- *8* ???*9*["attributeName"] - ⚠️ unknown object -- *9* ???*10*["type"] - ⚠️ unknown object -- *10* e - ⚠️ circular variable reference -- *11* arguments[2] - ⚠️ function calls are not analysed yet -- *12* (3 === (???*13* | ???*22*)) +- *5* ("function" === ???*6*) ⚠️ nested operation -- *13* (???*14* ? ???*20* : null) +- *6* typeof(???*7*) ⚠️ nested operation -- *14* (???*15* | ???*16*)((???*17* | ???*18*)) - ⚠️ non-function callee -- *15* FreeVar(undefined) +- *7* FreeVar(reportError) ⚠️ unknown global ⚠️ This value might have side effects -- *16* unknown mutation +- *8* FreeVar(reportError) + ⚠️ unknown global ⚠️ This value might have side effects -- *17* arguments[1] +- *9* ???*10*["onRecoverableError"] + ⚠️ unknown object +- *10* arguments[1] ⚠️ function calls are not analysed yet -- *18* ???*19*["attributeName"] +- *11* ???*12*["onRecoverableError"] ⚠️ unknown object -- *19* e - ⚠️ circular variable reference -- *20* {}[???*21*] - ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects -- *21* arguments[1] - ⚠️ function calls are not analysed yet -- *22* ???*23*["type"] +- *12* unknown new expression + ⚠️ This value might have side effects + +0 -> 117 conditional = (8 === ???*0*) +- *0* ???*1*["nodeType"] ⚠️ unknown object -- *23* e - ⚠️ circular variable reference -- *24* c - ⚠️ circular variable reference +- *1* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 172 free var = FreeVar(Symbol) +0 -> 119 call = (...) => undefined((???*0* ? ???*3* : ???*5*)) +- *0* (8 === ???*1*) + ⚠️ nested operation +- *1* ???*2*["nodeType"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["parentNode"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 173 member call = ???*0*["for"]("react.element") -- *0* FreeVar(Symbol) - ⚠️ unknown global +0 -> 120 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 175 free var = FreeVar(Symbol) +0 -> 122 free var = FreeVar(exports) -0 -> 176 member call = ???*0*["for"]("react.portal") -- *0* FreeVar(Symbol) - ⚠️ unknown global +0 -> 123 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 178 free var = FreeVar(Symbol) - -0 -> 179 member call = ???*0*["for"]("react.fragment") -- *0* FreeVar(Symbol) - ⚠️ unknown global +123 -> 124 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 181 free var = FreeVar(Symbol) - -0 -> 182 member call = ???*0*["for"]("react.strict_mode") -- *0* FreeVar(Symbol) - ⚠️ unknown global +123 -> 126 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 184 free var = FreeVar(Symbol) - -0 -> 185 member call = ???*0*["for"]("react.profiler") -- *0* FreeVar(Symbol) - ⚠️ unknown global +126 -> 127 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 187 free var = FreeVar(Symbol) +126 -> 129 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 188 member call = ???*0*["for"]("react.provider") -- *0* FreeVar(Symbol) - ⚠️ unknown global +129 -> 131 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 190 free var = FreeVar(Symbol) +131 -> 132 free var = FreeVar(Error) -0 -> 191 member call = ???*0*["for"]("react.context") -- *0* FreeVar(Symbol) +131 -> 133 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) + +131 -> 134 call = ???*0*( + `Minified React error #${188}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${188}` + ⚠️ nested operation -0 -> 193 free var = FreeVar(Symbol) +129 -> 137 free var = FreeVar(Object) -0 -> 194 member call = ???*0*["for"]("react.forward_ref") -- *0* FreeVar(Symbol) +129 -> 138 member call = ???*0*["keys"](???*1*) +- *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 196 free var = FreeVar(Symbol) - -0 -> 197 member call = ???*0*["for"]("react.suspense") -- *0* FreeVar(Symbol) +129 -> 139 member call = ???*0*["join"](",") +- *0* ???*1*["keys"](a) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *1* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 199 free var = FreeVar(Symbol) +129 -> 140 free var = FreeVar(Error) -0 -> 200 member call = ???*0*["for"]("react.suspense_list") -- *0* FreeVar(Symbol) - ⚠️ unknown global +129 -> 141 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(268, ???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 202 free var = FreeVar(Symbol) - -0 -> 203 member call = ???*0*["for"]("react.memo") -- *0* FreeVar(Symbol) +129 -> 142 call = ???*0*(???*1*) +- *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 205 free var = FreeVar(Symbol) - -0 -> 206 member call = ???*0*["for"]("react.lazy") -- *0* FreeVar(Symbol) - ⚠️ unknown global +126 -> 143 call = (...) => ((null !== a) ? $b(a) : null)(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 208 free var = FreeVar(Symbol) +126 -> 144 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 209 member call = ???*0*["for"]("react.scope") -- *0* FreeVar(Symbol) - ⚠️ unknown global +126 -> 146 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 211 free var = FreeVar(Symbol) +0 -> 148 free var = FreeVar(exports) -0 -> 212 member call = ???*0*["for"]("react.debug_trace_mode") -- *0* FreeVar(Symbol) - ⚠️ unknown global +0 -> 149 call = (...) => (undefined | a())(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 150 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 214 free var = FreeVar(Symbol) +0 -> 152 free var = FreeVar(exports) -0 -> 215 member call = ???*0*["for"]("react.offscreen") -- *0* FreeVar(Symbol) - ⚠️ unknown global - ⚠️ This value might have side effects +0 -> 153 call = (...) => !(( + || !(a) + || ( + && (1 !== a["nodeType"]) + && (9 !== a["nodeType"]) + && (11 !== a["nodeType"]) + && ( + || (8 !== a["nodeType"]) + || (" react-mount-point-unstable " !== a["nodeValue"]) + ) + ) +))(???*0*) +- *0* arguments[1] + ⚠️ function calls are not analysed yet -0 -> 217 free var = FreeVar(Symbol) +0 -> 154 conditional = !(???*0*) +- *0* !(???*1*) + ⚠️ nested operation +- *1* !(???*2*) + ⚠️ nested operation +- *2* arguments[1] + ⚠️ function calls are not analysed yet -0 -> 218 member call = ???*0*["for"]("react.legacy_hidden") -- *0* FreeVar(Symbol) - ⚠️ unknown global - ⚠️ This value might have side effects +154 -> 155 free var = FreeVar(Error) -0 -> 220 free var = FreeVar(Symbol) +154 -> 156 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) -0 -> 221 member call = ???*0*["for"]("react.cache") -- *0* FreeVar(Symbol) +154 -> 157 call = ???*0*( + `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` + ⚠️ nested operation -0 -> 223 free var = FreeVar(Symbol) +0 -> 158 call = (...) => hl(g)(null, ???*0*, ???*1*, true, ???*2*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet -0 -> 224 member call = ???*0*["for"]("react.tracing_marker") -- *0* FreeVar(Symbol) - ⚠️ unknown global +0 -> 159 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 226 free var = FreeVar(Symbol) +0 -> 161 free var = FreeVar(exports) -0 -> 229 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | ???*2* | ???*4*)) - ⚠️ nested operation -- *1* arguments[0] +0 -> 162 call = (...) => !(( + || !(a) + || ((1 !== a["nodeType"]) && (9 !== a["nodeType"]) && (11 !== a["nodeType"])) +))((???*0* | 0 | ???*1*)) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["iterator"] - ⚠️ unknown object +- *1* updated with update expression ⚠️ This value might have side effects -- *3* FreeVar(Symbol) + +0 -> 163 conditional = !(???*0*) +- *0* !(???*1*) + ⚠️ nested operation +- *1* !((???*2* | 0 | ???*3*)) + ⚠️ nested operation +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* updated with update expression + ⚠️ This value might have side effects + +163 -> 164 free var = FreeVar(Error) + +163 -> 165 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(405) + +163 -> 166 call = ???*0*( + `Minified React error #${405}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${405}` + ⚠️ nested operation + +0 -> 173 conditional = (null != (???*0* | ???*1* | null[(???*6* | 0 | ???*7*)])) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*[(???*4* | 0 | ???*5*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* (null != ???*3*) + ⚠️ nested operation +- *3* c + ⚠️ circular variable reference +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* updated with update expression + ⚠️ This value might have side effects +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* updated with update expression + ⚠️ This value might have side effects + +0 -> 174 call = (...) => a( + ???*0*, + null, + (???*1* | 0 | ???*2*), + 1, + (???*3* ? (???*12* | ???*13* | null[(???*18* | 0 | ???*19*)]) : null), + ( + | false + | true + | ???*20* + | (null != ???*22*)[(???*23* | 0 | ???*24*)]["_getVersion"] + | ???*25* + | null[(???*31* | 0 | ???*32*)]["_getVersion"] + | ???*33* + ), + false, + ( + | "" + | ???*35* + | (null != ???*37*)[(???*38* | 0 | ???*39*)]["identifierPrefix"] + | ???*40* + | null[(???*46* | 0 | ???*47*)]["identifierPrefix"] + ), + ( + | (???*48* ? ???*51* : (...) => undefined) + | ???*52* + | (null != ???*54*)[(???*55* | 0 | ???*56*)]["onRecoverableError"] + | ???*57* + | null[(???*63* | 0 | ???*64*)]["onRecoverableError"] + ) +) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* updated with update expression + ⚠️ This value might have side effects +- *3* (null != (???*4* | ???*5* | null[(???*10* | 0 | ???*11*)])) + ⚠️ nested operation +- *4* arguments[2] + ⚠️ function calls are not analysed yet +- *5* ???*6*[(???*8* | 0 | ???*9*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* (null != ???*7*) + ⚠️ nested operation +- *7* c + ⚠️ circular variable reference +- *8* arguments[0] + ⚠️ function calls are not analysed yet +- *9* updated with update expression + ⚠️ This value might have side effects +- *10* arguments[0] + ⚠️ function calls are not analysed yet +- *11* updated with update expression + ⚠️ This value might have side effects +- *12* arguments[2] + ⚠️ function calls are not analysed yet +- *13* ???*14*[(???*16* | 0 | ???*17*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *14* (null != ???*15*) + ⚠️ nested operation +- *15* c + ⚠️ circular variable reference +- *16* arguments[0] + ⚠️ function calls are not analysed yet +- *17* updated with update expression + ⚠️ This value might have side effects +- *18* arguments[0] + ⚠️ function calls are not analysed yet +- *19* updated with update expression + ⚠️ This value might have side effects +- *20* ???*21*["_getVersion"] + ⚠️ unknown object +- *21* arguments[2] + ⚠️ function calls are not analysed yet +- *22* c + ⚠️ circular variable reference +- *23* arguments[0] + ⚠️ function calls are not analysed yet +- *24* updated with update expression + ⚠️ This value might have side effects +- *25* ???*26*["_getVersion"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *26* ???*27*[(???*29* | 0 | ???*30*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *27* ???*28*["hydratedSources"] + ⚠️ unknown object +- *28* c + ⚠️ circular variable reference +- *29* arguments[0] + ⚠️ function calls are not analysed yet +- *30* updated with update expression + ⚠️ This value might have side effects +- *31* arguments[0] + ⚠️ function calls are not analysed yet +- *32* updated with update expression + ⚠️ This value might have side effects +- *33* ???*34*(c["_source"]) + ⚠️ unknown callee +- *34* e + ⚠️ circular variable reference +- *35* ???*36*["identifierPrefix"] + ⚠️ unknown object +- *36* arguments[2] + ⚠️ function calls are not analysed yet +- *37* c + ⚠️ circular variable reference +- *38* arguments[0] + ⚠️ function calls are not analysed yet +- *39* updated with update expression + ⚠️ This value might have side effects +- *40* ???*41*["identifierPrefix"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *41* ???*42*[(???*44* | 0 | ???*45*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *42* ???*43*["hydratedSources"] + ⚠️ unknown object +- *43* c + ⚠️ circular variable reference +- *44* arguments[0] + ⚠️ function calls are not analysed yet +- *45* updated with update expression + ⚠️ This value might have side effects +- *46* arguments[0] + ⚠️ function calls are not analysed yet +- *47* updated with update expression + ⚠️ This value might have side effects +- *48* ("function" === ???*49*) + ⚠️ nested operation +- *49* typeof(???*50*) + ⚠️ nested operation +- *50* FreeVar(reportError) + ⚠️ unknown global + ⚠️ This value might have side effects +- *51* FreeVar(reportError) + ⚠️ unknown global + ⚠️ This value might have side effects +- *52* ???*53*["onRecoverableError"] + ⚠️ unknown object +- *53* arguments[2] + ⚠️ function calls are not analysed yet +- *54* c + ⚠️ circular variable reference +- *55* arguments[0] + ⚠️ function calls are not analysed yet +- *56* updated with update expression + ⚠️ This value might have side effects +- *57* ???*58*["onRecoverableError"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *58* ???*59*[(???*61* | 0 | ???*62*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *59* ???*60*["hydratedSources"] + ⚠️ unknown object +- *60* c + ⚠️ circular variable reference +- *61* arguments[0] + ⚠️ function calls are not analysed yet +- *62* updated with update expression + ⚠️ This value might have side effects +- *63* arguments[0] + ⚠️ function calls are not analysed yet +- *64* updated with update expression + ⚠️ This value might have side effects + +0 -> 177 call = (...) => undefined((???*0* | 0 | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* updated with update expression + ⚠️ This value might have side effects + +0 -> 178 conditional = ((null != (???*0* | ???*1*)) | ???*3* | null) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*[a] + ⚠️ unknown object +- *2* d + ⚠️ circular variable reference +- *3* ???*4*["hydratedSources"] + ⚠️ unknown object +- *4* arguments[2] + ⚠️ function calls are not analysed yet + +178 -> 183 call = ( + | false + | true + | ???*0* + | (null != ???*2*)[(???*3* | 0 | ???*4*)]["_getVersion"] + | ???*5* + | null[(???*11* | 0 | ???*12*)]["_getVersion"] + | ???*13* +)( + ( + | ???*15* + | (null != ???*17*)[(???*18* | 0 | ???*19*)]["_source"] + | ???*20* + | null[(???*26* | 0 | ???*27*)]["_source"] + ) +) +- *0* ???*1*["_getVersion"] + ⚠️ unknown object +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* c + ⚠️ circular variable reference +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* updated with update expression + ⚠️ This value might have side effects +- *5* ???*6*["_getVersion"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* ???*7*[(???*9* | 0 | ???*10*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *7* ???*8*["hydratedSources"] + ⚠️ unknown object +- *8* c + ⚠️ circular variable reference +- *9* arguments[0] + ⚠️ function calls are not analysed yet +- *10* updated with update expression + ⚠️ This value might have side effects +- *11* arguments[0] + ⚠️ function calls are not analysed yet +- *12* updated with update expression + ⚠️ This value might have side effects +- *13* ???*14*(c["_source"]) + ⚠️ unknown callee +- *14* e + ⚠️ circular variable reference +- *15* ???*16*["_source"] + ⚠️ unknown object +- *16* arguments[2] + ⚠️ function calls are not analysed yet +- *17* c + ⚠️ circular variable reference +- *18* arguments[0] + ⚠️ function calls are not analysed yet +- *19* updated with update expression + ⚠️ This value might have side effects +- *20* ???*21*["_source"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *21* ???*22*[(???*24* | 0 | ???*25*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *22* ???*23*["hydratedSources"] + ⚠️ unknown object +- *23* c + ⚠️ circular variable reference +- *24* arguments[0] + ⚠️ function calls are not analysed yet +- *25* updated with update expression + ⚠️ This value might have side effects +- *26* arguments[0] + ⚠️ function calls are not analysed yet +- *27* updated with update expression + ⚠️ This value might have side effects + +178 -> 185 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +185 -> 189 member call = ???*0*["push"]( + (???*1* | (null != ???*2*)[(???*3* | 0 | ???*4*)] | ???*5* | null[(???*10* | 0 | ???*11*)]), + ( + | false + | true + | ???*12* + | (null != ???*14*)[(???*15* | 0 | ???*16*)]["_getVersion"] + | ???*17* + | null[(???*23* | 0 | ???*24*)]["_getVersion"] + | ???*25* + ) +) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* c + ⚠️ circular variable reference +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* updated with update expression + ⚠️ This value might have side effects +- *5* ???*6*[(???*8* | 0 | ???*9*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* ???*7*["hydratedSources"] + ⚠️ unknown object +- *7* c + ⚠️ circular variable reference +- *8* arguments[0] + ⚠️ function calls are not analysed yet +- *9* updated with update expression + ⚠️ This value might have side effects +- *10* arguments[0] + ⚠️ function calls are not analysed yet +- *11* updated with update expression + ⚠️ This value might have side effects +- *12* ???*13*["_getVersion"] + ⚠️ unknown object +- *13* arguments[2] + ⚠️ function calls are not analysed yet +- *14* c + ⚠️ circular variable reference +- *15* arguments[0] + ⚠️ function calls are not analysed yet +- *16* updated with update expression + ⚠️ This value might have side effects +- *17* ???*18*["_getVersion"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *18* ???*19*[(???*21* | 0 | ???*22*)] + ⚠️ unknown object + ⚠️ This value might have side effects +- *19* ???*20*["hydratedSources"] + ⚠️ unknown object +- *20* c + ⚠️ circular variable reference +- *21* arguments[0] + ⚠️ function calls are not analysed yet +- *22* updated with update expression + ⚠️ This value might have side effects +- *23* arguments[0] + ⚠️ function calls are not analysed yet +- *24* updated with update expression + ⚠️ This value might have side effects +- *25* ???*26*(c["_source"]) + ⚠️ unknown callee +- *26* e + ⚠️ circular variable reference + +0 -> 190 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 192 free var = FreeVar(exports) + +0 -> 193 call = (...) => !(( + || !(a) + || ( + && (1 !== a["nodeType"]) + && (9 !== a["nodeType"]) + && (11 !== a["nodeType"]) + && ( + || (8 !== a["nodeType"]) + || (" react-mount-point-unstable " !== a["nodeValue"]) + ) + ) +))(???*0*) +- *0* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 194 conditional = !(???*0*) +- *0* !(???*1*) + ⚠️ nested operation +- *1* !(???*2*) + ⚠️ nested operation +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +194 -> 195 free var = FreeVar(Error) + +194 -> 196 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) + +194 -> 197 call = ???*0*( + `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` + ⚠️ nested operation + +0 -> 198 call = (...) => hl(g)(null, ???*0*, ???*1*, false, ???*2*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet + +0 -> 199 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 201 free var = FreeVar(exports) + +0 -> 202 call = (...) => !(( + || !(a) + || ( + && (1 !== a["nodeType"]) + && (9 !== a["nodeType"]) + && (11 !== a["nodeType"]) + && ( + || (8 !== a["nodeType"]) + || (" react-mount-point-unstable " !== a["nodeValue"]) + ) + ) +))(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 203 conditional = !(???*0*) +- *0* !(???*1*) + ⚠️ nested operation +- *1* !(???*2*) + ⚠️ nested operation +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +203 -> 204 free var = FreeVar(Error) + +203 -> 205 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(40) + +203 -> 206 call = ???*0*( + `Minified React error #${40}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${40}` + ⚠️ nested operation + +0 -> 208 conditional = ???*0* +- *0* ???*1*["_reactRootContainer"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +208 -> 209 call = (...) => (undefined | a())((...) => undefined) + +209 -> 210 call = (...) => hl(g)(null, null, ???*0*, false, (...) => undefined) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 213 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 215 free var = FreeVar(exports) + +0 -> 217 free var = FreeVar(exports) + +0 -> 218 call = (...) => !(( + || !(a) + || ( + && (1 !== a["nodeType"]) + && (9 !== a["nodeType"]) + && (11 !== a["nodeType"]) + && ( + || (8 !== a["nodeType"]) + || (" react-mount-point-unstable " !== a["nodeValue"]) + ) + ) +))(???*0*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet + +0 -> 219 conditional = !(???*0*) +- *0* !(???*1*) + ⚠️ nested operation +- *1* !(???*2*) + ⚠️ nested operation +- *2* arguments[2] + ⚠️ function calls are not analysed yet + +219 -> 220 free var = FreeVar(Error) + +219 -> 221 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) + +219 -> 222 call = ???*0*( + `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` + ⚠️ nested operation + +0 -> 224 conditional = ((null == ???*0*) | (???*1* === ???*2*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* ???*3*["_reactInternals"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +224 -> 225 free var = FreeVar(Error) + +224 -> 226 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(38) + +224 -> 227 call = ???*0*( + `Minified React error #${38}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${38}` + ⚠️ nested operation + +0 -> 228 call = (...) => hl(g)(???*0*, ???*1*, ???*2*, false, ???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* arguments[3] + ⚠️ function calls are not analysed yet + +0 -> 229 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 231 free var = FreeVar(exports) + +0 -> 232 free var = FreeVar(require) + +0 -> 233 call = require*0*("react") +- *0* require: The require method from CommonJS + +0 -> 234 free var = FreeVar(require) + +0 -> 235 call = require*0*("scheduler") +- *0* require: The require method from CommonJS + +0 -> 237 free var = FreeVar(arguments) + +0 -> 238 free var = FreeVar(encodeURIComponent) + +0 -> 240 free var = FreeVar(arguments) + +0 -> 241 call = ???*0*(???*1*) +- *0* FreeVar(encodeURIComponent) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* ???*2*[c] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* FreeVar(arguments) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 242 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 243 free var = FreeVar(Set) + +0 -> 244 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 245 call = (...) => undefined(`${???*0*}Capture`, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 250 member call = ???*0*["add"](???*1*) +- *0* unknown new expression + ⚠️ This value might have side effects +- *1* ???*2*[a] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 251 free var = FreeVar(window) + +0 -> 253 free var = FreeVar(window) + +0 -> 256 free var = FreeVar(window) + +0 -> 259 free var = FreeVar(Object) + +0 -> 261 member call = ???*0*["call"]({}, ???*3*) +- *0* ???*1*["hasOwnProperty"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *1* ???*2*["prototype"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 262 conditional = ???*0* +- *0* ???*1*["call"](ma, a) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *1* ???*2*["hasOwnProperty"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* ???*3*["prototype"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *3* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects + +262 -> 263 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +262 -> 265 member call = ???*0*["call"]({}, ???*3*) +- *0* ???*1*["hasOwnProperty"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *1* ???*2*["prototype"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +262 -> 266 conditional = ???*0* +- *0* ???*1*["call"](la, a) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *1* ???*2*["hasOwnProperty"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* ???*3*["prototype"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *3* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects + +266 -> 267 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +266 -> 269 member call = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/["test"](???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +266 -> 270 conditional = /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/["test"](???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +270 -> 272 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +270 -> 274 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 276 conditional = ((null !== ???*0*) | (0 === ???*1*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[2] + ⚠️ function calls are not analysed yet + +276 -> 277 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +276 -> 278 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +276 -> 279 conditional = ???*0* +- *0* arguments[3] + ⚠️ function calls are not analysed yet + +279 -> 280 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +279 -> 281 conditional = (null !== ???*0*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet + +281 -> 283 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +281 -> 286 member call = (???*0* | ???*1*)["toLowerCase"]() +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*(0, 5) + ⚠️ unknown callee +- *2* ???*3*["slice"] + ⚠️ unknown object +- *3* ???*4*() + ⚠️ nested operation +- *4* ???*5*["toLowerCase"] + ⚠️ unknown object +- *5* a + ⚠️ circular variable reference + +281 -> 287 member call = ???*0*()["slice"](0, 5) +- *0* ???*1*["toLowerCase"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +281 -> 288 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +276 -> 289 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 290 call = (...) => (undefined | !(1) | !(0) | !(c["acceptsBooleans"]) | (("data-" !== a) && ("aria-" !== a)))(???*0*, ???*1*, ???*2*, ???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* arguments[3] + ⚠️ function calls are not analysed yet + +0 -> 291 conditional = ( + | (null === ???*0*) + | ("undefined" === ???*1*) + | undefined + | false + | true + | !(???*3*) + | ("data-" !== (???*5* | ???*6*)) + | ("aria-" !== (???*11* | ???*12*)) +) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* typeof(???*2*) + ⚠️ nested operation +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* ???*4*["acceptsBooleans"] + ⚠️ unknown object +- *4* arguments[2] + ⚠️ function calls are not analysed yet +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*(0, 5) + ⚠️ unknown callee +- *7* ???*8*["slice"] + ⚠️ unknown object +- *8* ???*9*() + ⚠️ nested operation +- *9* ???*10*["toLowerCase"] + ⚠️ unknown object +- *10* a + ⚠️ circular variable reference +- *11* arguments[0] + ⚠️ function calls are not analysed yet +- *12* ???*13*(0, 5) + ⚠️ unknown callee +- *13* ???*14*["slice"] + ⚠️ unknown object +- *14* ???*15*() + ⚠️ nested operation +- *15* ???*16*["toLowerCase"] + ⚠️ unknown object +- *16* a + ⚠️ circular variable reference + +291 -> 292 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +291 -> 293 conditional = ???*0* +- *0* arguments[3] + ⚠️ function calls are not analysed yet + +293 -> 294 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +293 -> 295 conditional = (null !== ???*0*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet + +295 -> 297 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +295 -> 298 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +295 -> 299 free var = FreeVar(isNaN) + +295 -> 300 call = ???*0*(???*1*) +- *0* FreeVar(isNaN) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +295 -> 301 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +295 -> 302 free var = FreeVar(isNaN) + +295 -> 303 call = ???*0*(???*1*) +- *0* FreeVar(isNaN) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +295 -> 304 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +293 -> 305 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 316 member call = "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"["split"](" ") + +0 -> 317 member call = "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"["split"](" ")["forEach"]((...) => undefined) + +0 -> 320 member call = [ + ["acceptCharset", "accept-charset"], + ["className", "class"], + ["htmlFor", "for"], + ["httpEquiv", "http-equiv"] +]["forEach"]((...) => undefined) + +0 -> 325 member call = ["contentEditable", "draggable", "spellCheck", "value"]["forEach"]((...) => undefined) + +325 -> 328 member call = ???*0*["toLowerCase"]() +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 330 member call = ["autoReverse", "externalResourcesRequired", "focusable", "preserveAlpha"]["forEach"]((...) => undefined) + +0 -> 334 member call = "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope"["split"](" ") + +0 -> 335 member call = "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope"["split"](" ")["forEach"]((...) => undefined) + +335 -> 338 member call = ???*0*["toLowerCase"]() +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 340 member call = ["checked", "multiple", "muted", "selected"]["forEach"]((...) => undefined) + +0 -> 343 member call = ["capture", "download"]["forEach"]((...) => undefined) + +0 -> 346 member call = ["cols", "rows", "size", "span"]["forEach"]((...) => undefined) + +0 -> 349 member call = ["rowSpan", "start"]["forEach"]((...) => undefined) + +349 -> 352 member call = ???*0*["toLowerCase"]() +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 355 member call = ???*0*["toUpperCase"]() +- *0* ???*1*[1] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 356 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 359 member call = "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height"["split"](" ") + +0 -> 360 member call = "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height"["split"](" ")["forEach"]((...) => undefined) + +360 -> 362 member call = ???*0*["replace"](/[\-:]([a-z])/g, (...) => a[1]["toUpperCase"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 366 member call = "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type"["split"](" ") + +0 -> 367 member call = "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type"["split"](" ")["forEach"]((...) => undefined) + +367 -> 369 member call = ???*0*["replace"](/[\-:]([a-z])/g, (...) => a[1]["toUpperCase"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 372 member call = ["xml:base", "xml:lang", "xml:space"]["forEach"]((...) => undefined) + +372 -> 374 member call = ???*0*["replace"](/[\-:]([a-z])/g, (...) => a[1]["toUpperCase"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 377 member call = ["tabIndex", "crossOrigin"]["forEach"]((...) => undefined) + +377 -> 380 member call = ???*0*["toLowerCase"]() +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 383 member call = ["src", "href", "action", "formAction"]["forEach"]((...) => undefined) + +383 -> 386 member call = ???*0*["toLowerCase"]() +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 388 member call = {}["hasOwnProperty"]( + (???*0* | (???*1* ? ???*5* : null)["attributeName"] | ???*7*) +) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* (???*2* | ???*3*)(???*4*) + ⚠️ non-function callee +- *2* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unknown mutation + ⚠️ This value might have side effects +- *4* b + ⚠️ circular variable reference +- *5* {}[???*6*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *6* b + ⚠️ circular variable reference +- *7* ???*8*["attributeName"] + ⚠️ unknown object +- *8* ???*9*["type"] + ⚠️ unknown object +- *9* e + ⚠️ circular variable reference + +0 -> 389 conditional = ???*0* +- *0* (???*1* | ???*2*)( + (???*3* | (???*4* ? ???*8* : null)["attributeName"] | ???*10*) + ) + ⚠️ non-function callee + ⚠️ This value might have side effects +- *1* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *2* unknown mutation + ⚠️ This value might have side effects +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* (???*5* | ???*6*)(???*7*) + ⚠️ non-function callee +- *5* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *6* unknown mutation + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* {}[???*9*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *9* b + ⚠️ circular variable reference +- *10* ???*11*["attributeName"] + ⚠️ unknown object +- *11* ???*12*["type"] + ⚠️ unknown object +- *12* e + ⚠️ circular variable reference + +0 -> 391 conditional = (null !== (???*0* | ???*9*)) +- *0* (???*1* ? ???*7* : null) + ⚠️ nested operation +- *1* (???*2* | ???*3*)((???*4* | ???*5*)) + ⚠️ non-function callee +- *2* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unknown mutation + ⚠️ This value might have side effects +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* ???*6*["attributeName"] + ⚠️ unknown object +- *6* e + ⚠️ circular variable reference +- *7* {}[???*8*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference + +0 -> 398 conditional = (???*0* ? ???*12* : (???*22* | ???*23* | ???*33*)) +- *0* (null !== (???*1* | ???*10*)) + ⚠️ nested operation +- *1* (???*2* ? ???*8* : null) + ⚠️ nested operation +- *2* (???*3* | ???*4*)((???*5* | ???*6*)) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* arguments[1] + ⚠️ function calls are not analysed yet +- *6* ???*7*["attributeName"] + ⚠️ unknown object +- *7* e + ⚠️ circular variable reference +- *8* {}[???*9*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *9* arguments[1] + ⚠️ function calls are not analysed yet +- *10* ???*11*["type"] + ⚠️ unknown object +- *11* e + ⚠️ circular variable reference +- *12* (0 !== ???*13*) + ⚠️ nested operation +- *13* ???*14*["type"] + ⚠️ unknown object +- *14* (???*15* ? ???*20* : null) + ⚠️ nested operation +- *15* (???*16* | ???*17*)((???*18* | ???*19*)) + ⚠️ non-function callee +- *16* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *17* unknown mutation + ⚠️ This value might have side effects +- *18* arguments[1] + ⚠️ function calls are not analysed yet +- *19* ???["attributeName"] + ⚠️ unknown object +- *20* {}[???*21*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *21* arguments[1] + ⚠️ function calls are not analysed yet +- *22* arguments[3] + ⚠️ function calls are not analysed yet +- *23* ???*24*["attributeNamespace"] + ⚠️ unknown object +- *24* (???*25* ? ???*31* : null) + ⚠️ nested operation +- *25* (???*26* | ???*27*)((???*28* | ???*29*)) + ⚠️ non-function callee +- *26* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *27* unknown mutation + ⚠️ This value might have side effects +- *28* arguments[1] + ⚠️ function calls are not analysed yet +- *29* ???*30*["attributeName"] + ⚠️ unknown object +- *30* e + ⚠️ circular variable reference +- *31* {}[???*32*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *32* arguments[1] + ⚠️ function calls are not analysed yet +- *33* !(???*34*) + ⚠️ nested operation +- *34* unsupported expression + ⚠️ This value might have side effects + +398 -> 399 call = (...) => (!(0) | !(1) | !(b) | (!(1) === b) | FreeVar(isNaN)(b) | (FreeVar(isNaN)(b) || ???*0*))( + (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*), + (???*11* | null | (???*12* ? "" : ???*24*)), + ((???*25* ? ???*31* : null) | ???*33*), + (???*35* | (???*36* ? ???*42* : null)["attributeNamespace"] | ???*44*) +) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)(???*5*) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* b + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* ???*9*["attributeName"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference +- *11* arguments[2] + ⚠️ function calls are not analysed yet +- *12* (3 === (???*13* | ???*22*)) + ⚠️ nested operation +- *13* (???*14* ? ???*20* : null) + ⚠️ nested operation +- *14* (???*15* | ???*16*)((???*17* | ???*18*)) + ⚠️ non-function callee +- *15* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *16* unknown mutation + ⚠️ This value might have side effects +- *17* arguments[1] + ⚠️ function calls are not analysed yet +- *18* ???*19*["attributeName"] + ⚠️ unknown object +- *19* e + ⚠️ circular variable reference +- *20* {}[???*21*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *21* arguments[1] + ⚠️ function calls are not analysed yet +- *22* ???*23*["type"] + ⚠️ unknown object +- *23* e + ⚠️ circular variable reference +- *24* c + ⚠️ circular variable reference +- *25* (???*26* | ???*27*)((???*28* | ???*29*)) + ⚠️ non-function callee +- *26* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *27* unknown mutation + ⚠️ This value might have side effects +- *28* arguments[1] + ⚠️ function calls are not analysed yet +- *29* ???*30*["attributeName"] + ⚠️ unknown object +- *30* e + ⚠️ circular variable reference +- *31* {}[???*32*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *32* arguments[1] + ⚠️ function calls are not analysed yet +- *33* ???*34*["type"] + ⚠️ unknown object +- *34* e + ⚠️ circular variable reference +- *35* arguments[3] + ⚠️ function calls are not analysed yet +- *36* (???*37* | ???*38*)((???*39* | ???*40*)) + ⚠️ non-function callee +- *37* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *38* unknown mutation + ⚠️ This value might have side effects +- *39* arguments[1] + ⚠️ function calls are not analysed yet +- *40* ???*41*["attributeName"] + ⚠️ unknown object +- *41* e + ⚠️ circular variable reference +- *42* {}[???*43*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *43* arguments[1] + ⚠️ function calls are not analysed yet +- *44* ???*45*["attributeNamespace"] + ⚠️ unknown object +- *45* ???*46*["type"] + ⚠️ unknown object +- *46* e + ⚠️ circular variable reference + +398 -> 400 conditional = (???*0* | (???*1* ? ???*7* : null)["attributeNamespace"] | ???*9* | (null === (???*12* | ???*21*))) +- *0* arguments[3] + ⚠️ function calls are not analysed yet +- *1* (???*2* | ???*3*)((???*4* | ???*5*)) + ⚠️ non-function callee +- *2* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unknown mutation + ⚠️ This value might have side effects +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* ???*6*["attributeName"] + ⚠️ unknown object +- *6* e + ⚠️ circular variable reference +- *7* {}[???*8*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* ???*10*["attributeNamespace"] + ⚠️ unknown object +- *10* ???*11*["type"] + ⚠️ unknown object +- *11* e + ⚠️ circular variable reference +- *12* (???*13* ? ???*19* : null) + ⚠️ nested operation +- *13* (???*14* | ???*15*)((???*16* | ???*17*)) + ⚠️ non-function callee +- *14* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *15* unknown mutation + ⚠️ This value might have side effects +- *16* arguments[1] + ⚠️ function calls are not analysed yet +- *17* ???*18*["attributeName"] + ⚠️ unknown object +- *18* e + ⚠️ circular variable reference +- *19* {}[???*20*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *20* arguments[1] + ⚠️ function calls are not analysed yet +- *21* ???*22*["type"] + ⚠️ unknown object +- *22* e + ⚠️ circular variable reference + +400 -> 401 call = (...) => (!(0) | !(1) | ???*0*)( + (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*) +) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)(???*5*) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* b + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* ???*9*["attributeName"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference + +400 -> 402 conditional = (null === (???*0* | null | ???*1*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* (???*2* ? "" : ???*13*) + ⚠️ nested operation +- *2* (3 === (???*3* | ???*11*)) + ⚠️ nested operation +- *3* (???*4* ? ???*9* : null) + ⚠️ nested operation +- *4* (???*5* | ???*6*)((???*7* | ???*8*)) + ⚠️ non-function callee +- *5* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *6* unknown mutation + ⚠️ This value might have side effects +- *7* arguments[1] + ⚠️ function calls are not analysed yet +- *8* ???["attributeName"] + ⚠️ unknown object +- *9* {}[???*10*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *10* arguments[1] + ⚠️ function calls are not analysed yet +- *11* ???*12*["type"] + ⚠️ unknown object +- *12* e + ⚠️ circular variable reference +- *13* c + ⚠️ circular variable reference + +402 -> 404 member call = ???*0*["removeAttribute"]( + (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)(???*5*) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* b + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* ???*9*["attributeName"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference + +402 -> 406 member call = ???*0*["setAttribute"]( + (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*), + (???*11* | null | (???*12* ? "" : ???*24*)) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)(???*5*) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* b + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* ???*9*["attributeName"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference +- *11* arguments[2] + ⚠️ function calls are not analysed yet +- *12* (3 === (???*13* | ???*22*)) + ⚠️ nested operation +- *13* (???*14* ? ???*20* : null) + ⚠️ nested operation +- *14* (???*15* | ???*16*)((???*17* | ???*18*)) + ⚠️ non-function callee +- *15* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *16* unknown mutation + ⚠️ This value might have side effects +- *17* arguments[1] + ⚠️ function calls are not analysed yet +- *18* ???*19*["attributeName"] + ⚠️ unknown object +- *19* e + ⚠️ circular variable reference +- *20* {}[???*21*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *21* arguments[1] + ⚠️ function calls are not analysed yet +- *22* ???*23*["type"] + ⚠️ unknown object +- *23* e + ⚠️ circular variable reference +- *24* c + ⚠️ circular variable reference + +400 -> 408 conditional = ((???*0* ? ???*6* : null)["mustUseProperty"] | ???*8*) +- *0* (???*1* | ???*2*)((???*3* | ???*4*)) + ⚠️ non-function callee +- *1* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *2* unknown mutation + ⚠️ This value might have side effects +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* ???*5*["attributeName"] + ⚠️ unknown object +- *5* e + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* arguments[1] + ⚠️ function calls are not analysed yet +- *8* ???*9*["mustUseProperty"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference + +408 -> 411 conditional = (null === (???*0* | null | ???*1*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* (???*2* ? "" : ???*13*) + ⚠️ nested operation +- *2* (3 === (???*3* | ???*11*)) + ⚠️ nested operation +- *3* (???*4* ? ???*9* : null) + ⚠️ nested operation +- *4* (???*5* | ???*6*)((???*7* | ???*8*)) + ⚠️ non-function callee +- *5* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *6* unknown mutation + ⚠️ This value might have side effects +- *7* arguments[1] + ⚠️ function calls are not analysed yet +- *8* ???["attributeName"] + ⚠️ unknown object +- *9* {}[???*10*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *10* arguments[1] + ⚠️ function calls are not analysed yet +- *11* ???*12*["type"] + ⚠️ unknown object +- *12* e + ⚠️ circular variable reference +- *13* c + ⚠️ circular variable reference + +411 -> 413 conditional = (3 === ???*0*) +- *0* ???*1*["type"] + ⚠️ unknown object +- *1* (???*2* ? ???*8* : null) + ⚠️ nested operation +- *2* (???*3* | ???*4*)((???*5* | ???*6*)) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* arguments[1] + ⚠️ function calls are not analysed yet +- *6* ???*7*["attributeName"] + ⚠️ unknown object +- *7* e + ⚠️ circular variable reference +- *8* {}[???*9*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *9* arguments[1] + ⚠️ function calls are not analysed yet + +408 -> 416 conditional = (null === (???*0* | null | ???*1*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* (???*2* ? "" : ???*13*) + ⚠️ nested operation +- *2* (3 === (???*3* | ???*11*)) + ⚠️ nested operation +- *3* (???*4* ? ???*9* : null) + ⚠️ nested operation +- *4* (???*5* | ???*6*)((???*7* | ???*8*)) + ⚠️ non-function callee +- *5* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *6* unknown mutation + ⚠️ This value might have side effects +- *7* arguments[1] + ⚠️ function calls are not analysed yet +- *8* ???["attributeName"] + ⚠️ unknown object +- *9* {}[???*10*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *10* arguments[1] + ⚠️ function calls are not analysed yet +- *11* ???*12*["type"] + ⚠️ unknown object +- *12* e + ⚠️ circular variable reference +- *13* c + ⚠️ circular variable reference + +416 -> 418 member call = ???*0*["removeAttribute"]( + (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)(???*5*) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* b + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* ???*9*["attributeName"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference + +416 -> 420 conditional = ((3 === (???*0* | ???*9*)) | (4 === (???*11* | ???*20*)) | (true === (???*22* | null | ???*23*))) +- *0* (???*1* ? ???*7* : null) + ⚠️ nested operation +- *1* (???*2* | ???*3*)((???*4* | ???*5*)) + ⚠️ non-function callee +- *2* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unknown mutation + ⚠️ This value might have side effects +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* ???*6*["attributeName"] + ⚠️ unknown object +- *6* e + ⚠️ circular variable reference +- *7* {}[???*8*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference +- *11* (???*12* ? ???*18* : null) + ⚠️ nested operation +- *12* (???*13* | ???*14*)((???*15* | ???*16*)) + ⚠️ non-function callee +- *13* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *14* unknown mutation + ⚠️ This value might have side effects +- *15* arguments[1] + ⚠️ function calls are not analysed yet +- *16* ???*17*["attributeName"] + ⚠️ unknown object +- *17* e + ⚠️ circular variable reference +- *18* {}[???*19*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *19* arguments[1] + ⚠️ function calls are not analysed yet +- *20* ???*21*["type"] + ⚠️ unknown object +- *21* e + ⚠️ circular variable reference +- *22* arguments[2] + ⚠️ function calls are not analysed yet +- *23* (???*24* ? "" : ???*35*) + ⚠️ nested operation +- *24* (3 === (???*25* | ???*33*)) + ⚠️ nested operation +- *25* (???*26* ? ???*31* : null) + ⚠️ nested operation +- *26* (???*27* | ???*28*)((???*29* | ???*30*)) + ⚠️ non-function callee +- *27* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *28* unknown mutation + ⚠️ This value might have side effects +- *29* arguments[1] + ⚠️ function calls are not analysed yet +- *30* ???["attributeName"] + ⚠️ unknown object +- *31* {}[???*32*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *32* arguments[1] + ⚠️ function calls are not analysed yet +- *33* ???*34*["type"] + ⚠️ unknown object +- *34* e + ⚠️ circular variable reference +- *35* c + ⚠️ circular variable reference + +416 -> 421 conditional = (???*0* | (???*1* ? ???*7* : null)["attributeNamespace"] | ???*9*) +- *0* arguments[3] + ⚠️ function calls are not analysed yet +- *1* (???*2* | ???*3*)((???*4* | ???*5*)) + ⚠️ non-function callee +- *2* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unknown mutation + ⚠️ This value might have side effects +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* ???*6*["attributeName"] + ⚠️ unknown object +- *6* e + ⚠️ circular variable reference +- *7* {}[???*8*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* ???*10*["attributeNamespace"] + ⚠️ unknown object +- *10* ???*11*["type"] + ⚠️ unknown object +- *11* e + ⚠️ circular variable reference + +421 -> 423 member call = ???*0*["setAttributeNS"]( + (???*1* | (???*2* ? ???*8* : null)["attributeNamespace"] | ???*10*), + (???*13* | (???*14* ? ???*18* : null)["attributeName"] | ???*20*), + (???*23* | null | (???*24* ? "" : ???*36*)) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[3] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)((???*5* | ???*6*)) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* arguments[1] + ⚠️ function calls are not analysed yet +- *6* ???*7*["attributeName"] + ⚠️ unknown object +- *7* e + ⚠️ circular variable reference +- *8* {}[???*9*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *9* arguments[1] + ⚠️ function calls are not analysed yet +- *10* ???*11*["attributeNamespace"] + ⚠️ unknown object +- *11* ???*12*["type"] + ⚠️ unknown object +- *12* e + ⚠️ circular variable reference +- *13* arguments[1] + ⚠️ function calls are not analysed yet +- *14* (???*15* | ???*16*)(???*17*) + ⚠️ non-function callee +- *15* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *16* unknown mutation + ⚠️ This value might have side effects +- *17* b + ⚠️ circular variable reference +- *18* {}[???*19*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *19* b + ⚠️ circular variable reference +- *20* ???*21*["attributeName"] + ⚠️ unknown object +- *21* ???*22*["type"] + ⚠️ unknown object +- *22* e + ⚠️ circular variable reference +- *23* arguments[2] + ⚠️ function calls are not analysed yet +- *24* (3 === (???*25* | ???*34*)) + ⚠️ nested operation +- *25* (???*26* ? ???*32* : null) + ⚠️ nested operation +- *26* (???*27* | ???*28*)((???*29* | ???*30*)) + ⚠️ non-function callee +- *27* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *28* unknown mutation + ⚠️ This value might have side effects +- *29* arguments[1] + ⚠️ function calls are not analysed yet +- *30* ???*31*["attributeName"] + ⚠️ unknown object +- *31* e + ⚠️ circular variable reference +- *32* {}[???*33*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *33* arguments[1] + ⚠️ function calls are not analysed yet +- *34* ???*35*["type"] + ⚠️ unknown object +- *35* e + ⚠️ circular variable reference +- *36* c + ⚠️ circular variable reference + +421 -> 425 member call = ???*0*["setAttribute"]( + (???*1* | (???*2* ? ???*6* : null)["attributeName"] | ???*8*), + (???*11* | null | (???*12* ? "" : ???*24*)) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (???*3* | ???*4*)(???*5*) + ⚠️ non-function callee +- *3* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unknown mutation + ⚠️ This value might have side effects +- *5* b + ⚠️ circular variable reference +- *6* {}[???*7*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *7* b + ⚠️ circular variable reference +- *8* ???*9*["attributeName"] + ⚠️ unknown object +- *9* ???*10*["type"] + ⚠️ unknown object +- *10* e + ⚠️ circular variable reference +- *11* arguments[2] + ⚠️ function calls are not analysed yet +- *12* (3 === (???*13* | ???*22*)) + ⚠️ nested operation +- *13* (???*14* ? ???*20* : null) + ⚠️ nested operation +- *14* (???*15* | ???*16*)((???*17* | ???*18*)) + ⚠️ non-function callee +- *15* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *16* unknown mutation + ⚠️ This value might have side effects +- *17* arguments[1] + ⚠️ function calls are not analysed yet +- *18* ???*19*["attributeName"] + ⚠️ unknown object +- *19* e + ⚠️ circular variable reference +- *20* {}[???*21*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *21* arguments[1] + ⚠️ function calls are not analysed yet +- *22* ???*23*["type"] + ⚠️ unknown object +- *23* e + ⚠️ circular variable reference +- *24* c + ⚠️ circular variable reference + +0 -> 428 free var = FreeVar(Symbol) + +0 -> 429 member call = ???*0*["for"]("react.element") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 431 free var = FreeVar(Symbol) + +0 -> 432 member call = ???*0*["for"]("react.portal") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 434 free var = FreeVar(Symbol) + +0 -> 435 member call = ???*0*["for"]("react.fragment") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 437 free var = FreeVar(Symbol) + +0 -> 438 member call = ???*0*["for"]("react.strict_mode") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 440 free var = FreeVar(Symbol) + +0 -> 441 member call = ???*0*["for"]("react.profiler") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 443 free var = FreeVar(Symbol) + +0 -> 444 member call = ???*0*["for"]("react.provider") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 446 free var = FreeVar(Symbol) + +0 -> 447 member call = ???*0*["for"]("react.context") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 449 free var = FreeVar(Symbol) + +0 -> 450 member call = ???*0*["for"]("react.forward_ref") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 452 free var = FreeVar(Symbol) + +0 -> 453 member call = ???*0*["for"]("react.suspense") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 455 free var = FreeVar(Symbol) + +0 -> 456 member call = ???*0*["for"]("react.suspense_list") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 458 free var = FreeVar(Symbol) + +0 -> 459 member call = ???*0*["for"]("react.memo") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 461 free var = FreeVar(Symbol) + +0 -> 462 member call = ???*0*["for"]("react.lazy") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 464 free var = FreeVar(Symbol) + +0 -> 465 member call = ???*0*["for"]("react.scope") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 467 free var = FreeVar(Symbol) + +0 -> 468 member call = ???*0*["for"]("react.debug_trace_mode") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 470 free var = FreeVar(Symbol) + +0 -> 471 member call = ???*0*["for"]("react.offscreen") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 473 free var = FreeVar(Symbol) + +0 -> 474 member call = ???*0*["for"]("react.legacy_hidden") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 476 free var = FreeVar(Symbol) + +0 -> 477 member call = ???*0*["for"]("react.cache") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 479 free var = FreeVar(Symbol) + +0 -> 480 member call = ???*0*["for"]("react.tracing_marker") +- *0* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 482 free var = FreeVar(Symbol) + +0 -> 483 conditional = ((null === (???*0* | ???*1* | ???*3*)) | ("object" !== ???*5*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["iterator"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* ???*4*[Ja] + ⚠️ unknown object +- *4* a + ⚠️ circular variable reference +- *5* typeof((???*6* | ???*7* | ???*9*)) + ⚠️ nested operation +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* ???*8*["iterator"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *8* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects +- *9* ???*10*[Ja] + ⚠️ unknown object +- *10* a + ⚠️ circular variable reference + +483 -> 484 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +483 -> 487 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | ???*2* | ???*4*)) + ⚠️ nested operation +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["iterator"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *3* FreeVar(Symbol) ⚠️ unknown global ⚠️ This value might have side effects - *4* ???*5*[Ja] @@ -1235,9 +3141,13 @@ - *5* a ⚠️ circular variable reference -0 -> 231 free var = FreeVar(Object) +483 -> 488 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 490 free var = FreeVar(Object) -0 -> 232 conditional = (???*0* === (???*1* | ???*2* | ???*7* | "")) +0 -> 491 conditional = (???*0* === (???*1* | ???*2* | ???*7* | "")) - *0* unsupported expression ⚠️ This value might have side effects - *1* La @@ -1263,20 +3173,20 @@ - *11* ???["trim"] ⚠️ unknown object -232 -> 233 free var = FreeVar(Error) +491 -> 492 free var = FreeVar(Error) -232 -> 234 call = ???*0*() +491 -> 493 call = ???*0*() - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -232 -> 238 member call = ???*0*["trim"]() +491 -> 497 member call = ???*0*["trim"]() - *0* ???*1*["stack"] ⚠️ unknown object - *1* c ⚠️ pattern without value -232 -> 239 member call = ???*0*()["match"](/\n( *(at )?)/) +491 -> 498 member call = ???*0*()["match"](/\n( *(at )?)/) - *0* ???*1*["trim"] ⚠️ unknown object - *1* ???*2*["stack"] @@ -1284,31 +3194,51 @@ - *2* c ⚠️ pattern without value -0 -> 242 free var = FreeVar(Error) +0 -> 500 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 501 conditional = (!((???*0* | ???*1*)) | false | true) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* (???*2* ? ???*3* : "") + ⚠️ nested operation +- *2* a + ⚠️ circular variable reference +- *3* ???*4*["displayName"] + ⚠️ unknown object +- *4* a + ⚠️ circular variable reference + +501 -> 502 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +501 -> 504 free var = FreeVar(Error) -0 -> 244 free var = FreeVar(Error) +501 -> 506 free var = FreeVar(Error) -0 -> 245 conditional = (???*0* | (...) => undefined) +501 -> 507 conditional = (???*0* | (...) => undefined) - *0* arguments[1] ⚠️ function calls are not analysed yet -245 -> 246 free var = FreeVar(Error) +507 -> 508 free var = FreeVar(Error) -245 -> 247 call = ???*0*() +507 -> 509 call = ???*0*() - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -245 -> 249 free var = FreeVar(Object) +507 -> 511 free var = FreeVar(Object) -245 -> 251 free var = FreeVar(Error) +507 -> 513 free var = FreeVar(Error) -245 -> 252 call = ???*0*() +507 -> 514 call = ???*0*() - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -245 -> 253 member call = ???*0*["defineProperty"]((???*1* | (...) => undefined["prototype"]), "props", {"set": (...) => undefined}) +507 -> 515 member call = ???*0*["defineProperty"]((???*1* | (...) => undefined["prototype"]), "props", {"set": (...) => undefined}) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects @@ -1317,22 +3247,22 @@ - *2* arguments[1] ⚠️ function calls are not analysed yet -245 -> 254 free var = FreeVar(Reflect) +507 -> 516 free var = FreeVar(Reflect) -245 -> 256 free var = FreeVar(Reflect) +507 -> 518 free var = FreeVar(Reflect) -245 -> 258 free var = FreeVar(Reflect) +507 -> 520 free var = FreeVar(Reflect) -245 -> 259 member call = ???*0*["construct"]((???*1* | (...) => undefined), []) +507 -> 521 member call = ???*0*["construct"]((???*1* | (...) => undefined), []) - *0* FreeVar(Reflect) ⚠️ unknown global ⚠️ This value might have side effects - *1* arguments[1] ⚠️ function calls are not analysed yet -245 -> 261 free var = FreeVar(Reflect) +507 -> 523 free var = FreeVar(Reflect) -245 -> 262 member call = ???*0*["construct"]((???*1* | (???*2* ? ???*3* : "")), [], (???*5* | (...) => undefined)) +507 -> 524 member call = ???*0*["construct"]((???*1* | (???*2* ? ???*3* : "")), [], (???*5* | (...) => undefined)) - *0* FreeVar(Reflect) ⚠️ unknown global ⚠️ This value might have side effects @@ -1347,11 +3277,11 @@ - *5* arguments[1] ⚠️ function calls are not analysed yet -245 -> 264 member call = (???*0* | (...) => undefined)["call"]() +507 -> 526 member call = (???*0* | (...) => undefined)["call"]() - *0* arguments[1] ⚠️ function calls are not analysed yet -245 -> 267 member call = (???*0* | (???*1* ? ???*2* : ""))["call"]((???*4* | (...) => undefined["prototype"])) +507 -> 529 member call = (???*0* | (???*1* ? ???*2* : ""))["call"]((???*4* | (...) => undefined["prototype"])) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a @@ -1365,14 +3295,14 @@ - *5* arguments[1] ⚠️ function calls are not analysed yet -245 -> 268 free var = FreeVar(Error) +507 -> 530 free var = FreeVar(Error) -245 -> 269 call = ???*0*() +507 -> 531 call = ???*0*() - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -245 -> 270 call = (???*0* | (???*1* ? ???*2* : ""))() +507 -> 532 call = (???*0* | (???*1* ? ???*2* : ""))() - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a @@ -1382,7 +3312,7 @@ - *3* a ⚠️ circular variable reference -0 -> 272 conditional = (???*0* | ("string" === ???*1*)) +501 -> 534 conditional = (???*0* | ("string" === ???*1*)) - *0* l ⚠️ pattern without value - *1* typeof(???*2*) @@ -1392,19 +3322,19 @@ - *3* l ⚠️ pattern without value -272 -> 275 member call = ???*0*["split"]("\n") +534 -> 537 member call = ???*0*["split"]("\n") - *0* ???*1*["stack"] ⚠️ unknown object - *1* l ⚠️ pattern without value -272 -> 278 member call = ???*0*["split"]("\n") +534 -> 540 member call = ???*0*["split"]("\n") - *0* ???*1*["stack"] ⚠️ unknown object - *1* l ⚠️ pattern without value -272 -> 285 conditional = (???*0* !== ???*4*) +534 -> 547 conditional = (???*0* !== ???*4*) - *0* ???*1*[g] ⚠️ unknown object - *1* ???*2*["split"]("\n") @@ -1422,13 +3352,13 @@ - *7* l ⚠️ pattern without value -285 -> 286 conditional = (1 !== (???*0* | ???*1*)) +547 -> 548 conditional = (1 !== (???*0* | ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* updated with update expression ⚠️ This value might have side effects -286 -> 291 member call = ???*0*["replace"](" at new ", " at ") +548 -> 553 member call = ???*0*["replace"](" at new ", " at ") - *0* ???*1*[g] ⚠️ unknown object - *1* ???*2*["split"]("\n") @@ -1438,7 +3368,7 @@ - *3* l ⚠️ pattern without value -286 -> 294 member call = ( +548 -> 556 member call = ( | ` ${???*0*}` | ???*5* @@ -1458,7 +3388,7 @@ ${???*0*}` - *6* k ⚠️ circular variable reference -286 -> 297 member call = ( +548 -> 559 member call = ( | ` ${???*0*}` | ???*5* @@ -1488,9 +3418,13 @@ ${???*0*}` - *11* a ⚠️ circular variable reference -0 -> 299 free var = FreeVar(Error) +548 -> 560 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +501 -> 562 free var = FreeVar(Error) -0 -> 300 conditional = (???*0* | (???*1* ? ???*2* : "")) +0 -> 563 conditional = (???*0* | (???*1* ? ???*2* : "")) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a @@ -1500,7 +3434,7 @@ ${???*0*}` - *3* a ⚠️ circular variable reference -0 -> 303 call = (...) => ` +0 -> 566 call = (...) => ` ${La}${a}`((???*0* | (???*1* ? ???*2* : ""))) - *0* arguments[0] ⚠️ function calls are not analysed yet @@ -1511,7 +3445,11 @@ ${La}${a}`((???*0* | (???*1* ? ???*2* : ""))) - *3* a ⚠️ circular variable reference -0 -> 306 call = (...) => ` +0 -> 567 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 570 call = (...) => ` ${La}${a}`( ( | ???*0* @@ -1645,16 +3583,32 @@ ${(???*44* | ???*45* | ???*49* | "")}${(???*53* | ???*55*)}` - *58* a ⚠️ circular variable reference -0 -> 307 call = (...) => ` +0 -> 571 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 572 call = (...) => ` ${La}${a}`("Lazy") -0 -> 308 call = (...) => ` +0 -> 573 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 574 call = (...) => ` ${La}${a}`("Suspense") -0 -> 309 call = (...) => ` +0 -> 575 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 576 call = (...) => ` ${La}${a}`("SuspenseList") -0 -> 311 call = (...) => ("" | k | (???*0* ? Ma(a) : ""))( +0 -> 577 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 579 call = (...) => ("" | k | (???*0* ? Ma(a) : ""))( ( | ???*1* | ""["type"] @@ -1790,281 +3744,343 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *59* a ⚠️ circular variable reference -0 -> 314 call = (...) => ("" | k | (???*0* ? Ma(a) : ""))( - ( - | ???*1* - | ""["type"]["render"] - | ` -${???*4*}`["type"]["render"] - | (???*9* ? ???*10* : "")["type"]["render"] - | (???*26* ? ???*27* : "")["type"]["render"] - | (???*44* ? ???*45* : "")["type"]["render"] - ), - false -) -- *0* unsupported expression +0 -> 580 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 583 call = (...) => ("" | k | (???*0* ? Ma(a) : ""))( + ( + | ???*1* + | ""["type"]["render"] + | ` +${???*4*}`["type"]["render"] + | (???*9* ? ???*10* : "")["type"]["render"] + | (???*26* ? ???*27* : "")["type"]["render"] + | (???*44* ? ???*45* : "")["type"]["render"] + ), + false +) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* ???*2*["render"] + ⚠️ unknown object +- *2* ???*3*["type"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["replace"](" at new ", " at ") + ⚠️ unknown callee object +- *5* ???*6*[g] + ⚠️ unknown object +- *6* ???*7*["split"]("\n") + ⚠️ unknown callee object +- *7* ???*8*["stack"] + ⚠️ unknown object +- *8* l + ⚠️ pattern without value +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* ` +${(???*11* | ???*12* | ???*16* | "")}${(???*20* | ???*22*)}` + ⚠️ nested operation +- *11* La + ⚠️ pattern without value +- *12* ???*13*(/\n( *(at )?)/) + ⚠️ unknown callee +- *13* ???*14*["match"] + ⚠️ unknown object +- *14* ???*15*() + ⚠️ nested operation +- *15* ...[...] + ⚠️ unknown object +- *16* ???*17*[1] + ⚠️ unknown object +- *17* ???*18*(/\n( *(at )?)/) + ⚠️ unknown callee +- *18* ???*19*["match"] + ⚠️ unknown object +- *19* ...() + ⚠️ nested operation +- *20* ???*21*["type"] + ⚠️ unknown object +- *21* a + ⚠️ circular variable reference +- *22* (???*23* ? ???*24* : "") + ⚠️ nested operation +- *23* a + ⚠️ circular variable reference +- *24* ???*25*["displayName"] + ⚠️ unknown object +- *25* a + ⚠️ circular variable reference +- *26* unsupported expression + ⚠️ This value might have side effects +- *27* ` +${(???*28* | ???*29* | ???*33* | "")}${(???*37* | ???*40*)}` + ⚠️ nested operation +- *28* La + ⚠️ pattern without value +- *29* ???*30*(/\n( *(at )?)/) + ⚠️ unknown callee +- *30* ???*31*["match"] + ⚠️ unknown object +- *31* ???*32*() + ⚠️ nested operation +- *32* ...[...] + ⚠️ unknown object +- *33* ???*34*[1] + ⚠️ unknown object +- *34* ???*35*(/\n( *(at )?)/) + ⚠️ unknown callee +- *35* ???*36*["match"] + ⚠️ unknown object +- *36* ...() + ⚠️ nested operation +- *37* ???*38*["render"] + ⚠️ unknown object +- *38* ???*39*["type"] + ⚠️ unknown object +- *39* a + ⚠️ circular variable reference +- *40* (???*41* ? ???*42* : "") + ⚠️ nested operation +- *41* a + ⚠️ circular variable reference +- *42* ???*43*["displayName"] + ⚠️ unknown object +- *43* a + ⚠️ circular variable reference +- *44* unsupported expression + ⚠️ This value might have side effects +- *45* ` +${(???*46* | ???*47* | ???*51* | "")}${(???*55* | ???*57*)}` + ⚠️ nested operation +- *46* La + ⚠️ pattern without value +- *47* ???*48*(/\n( *(at )?)/) + ⚠️ unknown callee +- *48* ???*49*["match"] + ⚠️ unknown object +- *49* ???*50*() + ⚠️ nested operation +- *50* ...[...] + ⚠️ unknown object +- *51* ???*52*[1] + ⚠️ unknown object +- *52* ???*53*(/\n( *(at )?)/) + ⚠️ unknown callee +- *53* ???*54*["match"] + ⚠️ unknown object +- *54* ...() + ⚠️ nested operation +- *55* ???*56*["type"] + ⚠️ unknown object +- *56* a + ⚠️ circular variable reference +- *57* (???*58* ? ???*59* : "") + ⚠️ nested operation +- *58* a + ⚠️ circular variable reference +- *59* ???*60*["displayName"] + ⚠️ unknown object +- *60* a + ⚠️ circular variable reference + +0 -> 584 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 586 call = (...) => ("" | k | (???*0* ? Ma(a) : ""))( + ( + | ???*1* + | ""["type"] + | ` +${???*3*}`["type"] + | (???*8* ? ???*9* : "")["type"] + | (???*25* ? ???*26* : "")["type"] + | (???*43* ? ???*44* : "")["type"] + ), + true +) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["replace"](" at new ", " at ") + ⚠️ unknown callee object +- *4* ???*5*[g] + ⚠️ unknown object +- *5* ???*6*["split"]("\n") + ⚠️ unknown callee object +- *6* ???*7*["stack"] + ⚠️ unknown object +- *7* l + ⚠️ pattern without value +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* ` +${(???*10* | ???*11* | ???*15* | "")}${(???*19* | ???*21*)}` + ⚠️ nested operation +- *10* La + ⚠️ pattern without value +- *11* ???*12*(/\n( *(at )?)/) + ⚠️ unknown callee +- *12* ???*13*["match"] + ⚠️ unknown object +- *13* ???*14*() + ⚠️ nested operation +- *14* ???["trim"] + ⚠️ unknown object +- *15* ???*16*[1] + ⚠️ unknown object +- *16* ???*17*(/\n( *(at )?)/) + ⚠️ unknown callee +- *17* ???*18*["match"] + ⚠️ unknown object +- *18* ???() + ⚠️ nested operation +- *19* ???*20*["type"] + ⚠️ unknown object +- *20* a + ⚠️ circular variable reference +- *21* (???*22* ? ???*23* : "") + ⚠️ nested operation +- *22* a + ⚠️ circular variable reference +- *23* ???*24*["displayName"] + ⚠️ unknown object +- *24* a + ⚠️ circular variable reference +- *25* unsupported expression + ⚠️ This value might have side effects +- *26* ` +${(???*27* | ???*28* | ???*32* | "")}${(???*36* | ???*39*)}` + ⚠️ nested operation +- *27* La + ⚠️ pattern without value +- *28* ???*29*(/\n( *(at )?)/) + ⚠️ unknown callee +- *29* ???*30*["match"] + ⚠️ unknown object +- *30* ???*31*() + ⚠️ nested operation +- *31* ???["trim"] + ⚠️ unknown object +- *32* ???*33*[1] + ⚠️ unknown object +- *33* ???*34*(/\n( *(at )?)/) + ⚠️ unknown callee +- *34* ???*35*["match"] + ⚠️ unknown object +- *35* ???() + ⚠️ nested operation +- *36* ???*37*["render"] + ⚠️ unknown object +- *37* ???*38*["type"] + ⚠️ unknown object +- *38* a + ⚠️ circular variable reference +- *39* (???*40* ? ???*41* : "") + ⚠️ nested operation +- *40* a + ⚠️ circular variable reference +- *41* ???*42*["displayName"] + ⚠️ unknown object +- *42* a + ⚠️ circular variable reference +- *43* unsupported expression + ⚠️ This value might have side effects +- *44* ` +${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` + ⚠️ nested operation +- *45* La + ⚠️ pattern without value +- *46* ???*47*(/\n( *(at )?)/) + ⚠️ unknown callee +- *47* ???*48*["match"] + ⚠️ unknown object +- *48* ???*49*() + ⚠️ nested operation +- *49* ???["trim"] + ⚠️ unknown object +- *50* ???*51*[1] + ⚠️ unknown object +- *51* ???*52*(/\n( *(at )?)/) + ⚠️ unknown callee +- *52* ???*53*["match"] + ⚠️ unknown object +- *53* ???() + ⚠️ nested operation +- *54* ???*55*["type"] + ⚠️ unknown object +- *55* a + ⚠️ circular variable reference +- *56* (???*57* ? ???*58* : "") + ⚠️ nested operation +- *57* a + ⚠️ circular variable reference +- *58* ???*59*["displayName"] + ⚠️ unknown object +- *59* a + ⚠️ circular variable reference + +0 -> 587 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* ???*2*["render"] - ⚠️ unknown object -- *2* ???*3*["type"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["replace"](" at new ", " at ") - ⚠️ unknown callee object -- *5* ???*6*[g] - ⚠️ unknown object -- *6* ???*7*["split"]("\n") - ⚠️ unknown callee object -- *7* ???*8*["stack"] - ⚠️ unknown object -- *8* l - ⚠️ pattern without value -- *9* unsupported expression - ⚠️ This value might have side effects -- *10* ` -${(???*11* | ???*12* | ???*16* | "")}${(???*20* | ???*22*)}` - ⚠️ nested operation -- *11* La - ⚠️ pattern without value -- *12* ???*13*(/\n( *(at )?)/) - ⚠️ unknown callee -- *13* ???*14*["match"] - ⚠️ unknown object -- *14* ???*15*() - ⚠️ nested operation -- *15* ...[...] - ⚠️ unknown object -- *16* ???*17*[1] - ⚠️ unknown object -- *17* ???*18*(/\n( *(at )?)/) - ⚠️ unknown callee -- *18* ???*19*["match"] - ⚠️ unknown object -- *19* ...() - ⚠️ nested operation -- *20* ???*21*["type"] - ⚠️ unknown object -- *21* a - ⚠️ circular variable reference -- *22* (???*23* ? ???*24* : "") - ⚠️ nested operation -- *23* a - ⚠️ circular variable reference -- *24* ???*25*["displayName"] - ⚠️ unknown object -- *25* a - ⚠️ circular variable reference -- *26* unsupported expression + +0 -> 588 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *27* ` -${(???*28* | ???*29* | ???*33* | "")}${(???*37* | ???*40*)}` - ⚠️ nested operation -- *28* La - ⚠️ pattern without value -- *29* ???*30*(/\n( *(at )?)/) - ⚠️ unknown callee -- *30* ???*31*["match"] - ⚠️ unknown object -- *31* ???*32*() - ⚠️ nested operation -- *32* ...[...] - ⚠️ unknown object -- *33* ???*34*[1] - ⚠️ unknown object -- *34* ???*35*(/\n( *(at )?)/) - ⚠️ unknown callee -- *35* ???*36*["match"] - ⚠️ unknown object -- *36* ...() - ⚠️ nested operation -- *37* ???*38*["render"] - ⚠️ unknown object -- *38* ???*39*["type"] - ⚠️ unknown object -- *39* a - ⚠️ circular variable reference -- *40* (???*41* ? ???*42* : "") - ⚠️ nested operation -- *41* a - ⚠️ circular variable reference -- *42* ???*43*["displayName"] + +0 -> 589 conditional = (null == (???*0* | ???*1* | null["displayName"] | null["name"] | "" | ???*3*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["displayName"] ⚠️ unknown object -- *43* a +- *2* a ⚠️ circular variable reference -- *44* unsupported expression - ⚠️ This value might have side effects -- *45* ` -${(???*46* | ???*47* | ???*51* | "")}${(???*55* | ???*57*)}` - ⚠️ nested operation -- *46* La - ⚠️ pattern without value -- *47* ???*48*(/\n( *(at )?)/) - ⚠️ unknown callee -- *48* ???*49*["match"] - ⚠️ unknown object -- *49* ???*50*() +- *3* (???*4* ? ???*6* : "ForwardRef") ⚠️ nested operation -- *50* ...[...] - ⚠️ unknown object -- *51* ???*52*[1] - ⚠️ unknown object -- *52* ???*53*(/\n( *(at )?)/) - ⚠️ unknown callee -- *53* ???*54*["match"] - ⚠️ unknown object -- *54* ...() +- *4* ("" !== ???*5*) ⚠️ nested operation -- *55* ???*56*["type"] - ⚠️ unknown object -- *56* a +- *5* a ⚠️ circular variable reference -- *57* (???*58* ? ???*59* : "") +- *6* `ForwardRef(${???*7*})` ⚠️ nested operation -- *58* a - ⚠️ circular variable reference -- *59* ???*60*["displayName"] - ⚠️ unknown object -- *60* a +- *7* a ⚠️ circular variable reference -0 -> 316 call = (...) => ("" | k | (???*0* ? Ma(a) : ""))( - ( - | ???*1* - | ""["type"] - | ` -${???*3*}`["type"] - | (???*8* ? ???*9* : "")["type"] - | (???*25* ? ???*26* : "")["type"] - | (???*43* ? ???*44* : "")["type"] - ), - true -) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* ???*2*["type"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["replace"](" at new ", " at ") - ⚠️ unknown callee object -- *4* ???*5*[g] - ⚠️ unknown object -- *5* ???*6*["split"]("\n") - ⚠️ unknown callee object -- *6* ???*7*["stack"] - ⚠️ unknown object -- *7* l - ⚠️ pattern without value -- *8* unsupported expression +589 -> 590 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *9* ` -${(???*10* | ???*11* | ???*15* | "")}${(???*19* | ???*21*)}` - ⚠️ nested operation -- *10* La - ⚠️ pattern without value -- *11* ???*12*(/\n( *(at )?)/) - ⚠️ unknown callee -- *12* ???*13*["match"] - ⚠️ unknown object -- *13* ???*14*() - ⚠️ nested operation -- *14* ???["trim"] - ⚠️ unknown object -- *15* ???*16*[1] - ⚠️ unknown object -- *16* ???*17*(/\n( *(at )?)/) - ⚠️ unknown callee -- *17* ???*18*["match"] - ⚠️ unknown object -- *18* ???() - ⚠️ nested operation -- *19* ???*20*["type"] - ⚠️ unknown object -- *20* a - ⚠️ circular variable reference -- *21* (???*22* ? ???*23* : "") + +589 -> 591 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | ???*2* | null["displayName"] | null["name"] | "" | ???*4*)) ⚠️ nested operation -- *22* a - ⚠️ circular variable reference -- *23* ???*24*["displayName"] +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["displayName"] ⚠️ unknown object -- *24* a +- *3* a ⚠️ circular variable reference -- *25* unsupported expression - ⚠️ This value might have side effects -- *26* ` -${(???*27* | ???*28* | ???*32* | "")}${(???*36* | ???*39*)}` - ⚠️ nested operation -- *27* La - ⚠️ pattern without value -- *28* ???*29*(/\n( *(at )?)/) - ⚠️ unknown callee -- *29* ???*30*["match"] - ⚠️ unknown object -- *30* ???*31*() +- *4* (???*5* ? ???*7* : "ForwardRef") ⚠️ nested operation -- *31* ???["trim"] - ⚠️ unknown object -- *32* ???*33*[1] - ⚠️ unknown object -- *33* ???*34*(/\n( *(at )?)/) - ⚠️ unknown callee -- *34* ???*35*["match"] - ⚠️ unknown object -- *35* ???() +- *5* ("" !== ???*6*) ⚠️ nested operation -- *36* ???*37*["render"] - ⚠️ unknown object -- *37* ???*38*["type"] - ⚠️ unknown object -- *38* a +- *6* a ⚠️ circular variable reference -- *39* (???*40* ? ???*41* : "") +- *7* `ForwardRef(${???*8*})` ⚠️ nested operation -- *40* a - ⚠️ circular variable reference -- *41* ???*42*["displayName"] - ⚠️ unknown object -- *42* a +- *8* a ⚠️ circular variable reference -- *43* unsupported expression + +591 -> 594 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *44* ` -${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - ⚠️ nested operation -- *45* La - ⚠️ pattern without value -- *46* ???*47*(/\n( *(at )?)/) - ⚠️ unknown callee -- *47* ???*48*["match"] - ⚠️ unknown object -- *48* ???*49*() - ⚠️ nested operation -- *49* ???["trim"] - ⚠️ unknown object -- *50* ???*51*[1] - ⚠️ unknown object -- *51* ???*52*(/\n( *(at )?)/) - ⚠️ unknown callee -- *52* ???*53*["match"] - ⚠️ unknown object -- *53* ???() - ⚠️ nested operation -- *54* ???*55*["type"] - ⚠️ unknown object -- *55* a - ⚠️ circular variable reference -- *56* (???*57* ? ???*58* : "") - ⚠️ nested operation -- *57* a - ⚠️ circular variable reference -- *58* ???*59*["displayName"] - ⚠️ unknown object -- *59* a - ⚠️ circular variable reference -0 -> 317 conditional = ("function" === ???*0*) +591 -> 595 conditional = ("string" === ???*0*) - *0* typeof((???*1* | ???*2* | null["displayName"] | null["name"] | "" | ???*4*)) ⚠️ nested operation - *1* arguments[0] @@ -2084,7 +4100,35 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* a ⚠️ circular variable reference -0 -> 320 conditional = ("object" === ???*0*) +595 -> 596 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 597 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 598 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 599 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 600 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 601 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 602 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 603 conditional = ("object" === ???*0*) - *0* typeof((???*1* | ???*2* | null["displayName"] | null["name"] | "" | ???*4*)) ⚠️ nested operation - *1* arguments[0] @@ -2104,7 +4148,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* a ⚠️ circular variable reference -320 -> 329 conditional = ("" !== (???*0* | ???*1* | null["displayName"] | null["name"] | "" | ???*3*)) +603 -> 606 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +603 -> 609 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +603 -> 614 conditional = ("" !== (???*0* | ???*1* | null["displayName"] | null["name"] | "" | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["displayName"] @@ -2122,13 +4174,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* a ⚠️ circular variable reference -320 -> 331 conditional = (null !== (???*0* | ""["render"] | ""["displayName"] | null | ""["_payload"])) +603 -> 615 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +603 -> 617 conditional = (null !== (???*0* | ""["render"] | ""["displayName"] | null | ""["_payload"])) - *0* ???*1*["render"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -331 -> 333 call = (...) => ( +617 -> 619 call = (...) => ( | null | (a["displayName"] || a["name"] || null) | a @@ -2167,7 +4223,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -320 -> 336 call = (???*0* | ???*1* | null["displayName"] | null["name"] | "" | (???*3* ? ???*5* : "ForwardRef"))( +603 -> 620 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +603 -> 623 call = (???*0* | ???*1* | null["displayName"] | null["name"] | "" | (???*3* ? ???*5* : "ForwardRef"))( ( | ???*7* | ""["render"] @@ -2222,7 +4282,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *20* a ⚠️ circular variable reference -320 -> 337 call = (...) => ( +603 -> 624 call = (...) => ( | null | (a["displayName"] || a["name"] || null) | a @@ -2257,7 +4317,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* a ⚠️ circular variable reference -0 -> 347 conditional = ("" !== (???*0* | ???*1* | "")) +603 -> 625 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +595 -> 626 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 629 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 631 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 634 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 635 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 640 conditional = ("" !== (???*0* | ???*1* | "")) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["render"] @@ -2267,7 +4351,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* a ⚠️ circular variable reference -0 -> 348 call = (...) => ( +0 -> 641 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 642 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 643 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 644 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 645 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 646 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 647 call = (...) => ( | null | (a["displayName"] || a["name"] || null) | a @@ -2290,7 +4398,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 349 conditional = ((???*0* | ""["type"]) === ???*2*) +0 -> 648 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 649 conditional = ((???*0* | ""["type"]) === ???*2*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] @@ -2302,7 +4414,47 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 350 conditional = ("function" === ???*0*) +0 -> 650 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 651 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 652 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 653 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 654 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 655 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 656 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 657 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | ""["type"])) + ⚠️ nested operation +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +657 -> 660 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +657 -> 661 conditional = ("string" === ???*0*) - *0* typeof((???*1* | ""["type"])) ⚠️ nested operation - *1* ???*2*["type"] @@ -2310,7 +4462,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 356 member call = (???*0* | ???*1*)["toLowerCase"]() +661 -> 662 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 663 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 664 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 665 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 666 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 670 member call = (???*0* | ???*1*)["toLowerCase"]() - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["nodeName"] @@ -2318,13 +4490,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* a ⚠️ circular variable reference -0 -> 357 call = (...) => (???*0* && ("input" === a["toLowerCase"]()) && (("checkbox" === b) || ("radio" === b)))(???*1*) +0 -> 671 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 672 call = (...) => (???*0* && ("input" === a["toLowerCase"]()) && (("checkbox" === b) || ("radio" === b)))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 358 conditional = (???*0* | ("input" === ???*1*) | ("checkbox" === ???*4*) | ("radio" === ???*6*)) +0 -> 673 conditional = (???*0* | ("input" === ???*1*) | ("checkbox" === ???*4*) | ("radio" === ???*6*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*() @@ -2342,9 +4518,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[0] ⚠️ function calls are not analysed yet -0 -> 360 free var = FreeVar(Object) +0 -> 675 free var = FreeVar(Object) -0 -> 363 member call = ???*0*["getOwnPropertyDescriptor"](???*1*, ((???*4* | ???*5*) ? "checked" : "value")) +0 -> 678 member call = ???*0*["getOwnPropertyDescriptor"](???*1*, ((???*4* | ???*5*) ? "checked" : "value")) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects @@ -2365,7 +4541,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[0] ⚠️ function calls are not analysed yet -0 -> 366 member call = ???*0*["hasOwnProperty"](((???*1* | ???*2*) ? "checked" : "value")) +0 -> 681 member call = ???*0*["hasOwnProperty"](((???*1* | ???*2*) ? "checked" : "value")) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -2379,7 +4555,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 369 conditional = (!(???*0*) | ("undefined" !== ???*2*) | ("function" === ???*5*)) +0 -> 684 conditional = (!(???*0*) | ("undefined" !== ???*2*) | ("function" === ???*5*)) - *0* ???*1*["hasOwnProperty"](b) ⚠️ unknown callee object - *1* arguments[0] @@ -2404,9 +4580,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -369 -> 373 free var = FreeVar(Object) +684 -> 688 free var = FreeVar(Object) -369 -> 375 member call = ???*0*["call"](???*3*) +684 -> 690 member call = ???*0*["call"](???*3*) - *0* ???*1*["get"] ⚠️ unknown object ⚠️ This value might have side effects @@ -2419,7 +4595,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -369 -> 377 member call = ???*0*["call"](???*3*, ???*4*) +684 -> 691 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +684 -> 693 member call = ???*0*["call"](???*3*, ???*4*) - *0* ???*1*["set"] ⚠️ unknown object ⚠️ This value might have side effects @@ -2434,7 +4614,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -369 -> 378 member call = ???*0*["defineProperty"]( +684 -> 694 member call = ???*0*["defineProperty"]( ???*1*, ((???*2* | ???*3*) ? "checked" : "value"), {"configurable": true, "get": (...) => e["call"](???*7*), "set": (...) => undefined} @@ -2457,9 +4637,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported expression ⚠️ This value might have side effects -369 -> 380 free var = FreeVar(Object) +684 -> 696 free var = FreeVar(Object) -369 -> 382 member call = ???*0*["defineProperty"](???*1*, ((???*2* | ???*3*) ? "checked" : "value"), {"enumerable": ???*7*}) +684 -> 698 member call = ???*0*["defineProperty"](???*1*, ((???*2* | ???*3*) ? "checked" : "value"), {"enumerable": ???*7*}) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects @@ -2485,7 +4665,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 387 call = (...) => ( +684 -> 699 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +684 -> 702 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 705 call = (...) => ( | undefined | { "getValue": *anonymous function 10089*, @@ -2496,7 +4684,47 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 390 member call = ( +0 -> 706 conditional = !((???*0* | "" | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ((???*2* | ???*3*) ? ???*7* : ???*10*) + ⚠️ nested operation +- *2* unsupported expression + ⚠️ This value might have side effects +- *3* ("input" === ???*4*) + ⚠️ nested operation +- *4* ???*5*() + ⚠️ nested operation +- *5* ???*6*["toLowerCase"] + ⚠️ unknown object +- *6* a + ⚠️ circular variable reference +- *7* (???*8* ? "true" : "false") + ⚠️ nested operation +- *8* ???*9*["checked"] + ⚠️ unknown object +- *9* a + ⚠️ circular variable reference +- *10* ???*11*["value"] + ⚠️ unknown object +- *11* a + ⚠️ circular variable reference + +706 -> 707 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +706 -> 709 conditional = !((???*0* | ""["_valueTracker"])) +- *0* ???*1*["_valueTracker"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +709 -> 710 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +709 -> 712 member call = ( | ???*0* | ""["_valueTracker"] | ((???*2* | ???*3*) ? ???*7* : ???*10*)["_valueTracker"] @@ -2526,7 +4754,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* a ⚠️ circular variable reference -0 -> 391 call = (...) => (???*0* && ("input" === a["toLowerCase"]()) && (("checkbox" === b) || ("radio" === b)))( +709 -> 713 call = (...) => (???*0* && ("input" === a["toLowerCase"]()) && (("checkbox" === b) || ("radio" === b)))( (???*1* | "" | ((???*2* | ???*3*) ? ???*7* : ???*10*)) ) - *0* unsupported expression @@ -2554,7 +4782,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* a ⚠️ circular variable reference -0 -> 392 conditional = ( +709 -> 714 conditional = ( | ???*0* | ("input" === ???*1*) | ("checkbox" === (???*4* | ""["type"])) @@ -2577,7 +4805,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[0] ⚠️ function calls are not analysed yet -392 -> 394 conditional = (???*0* | ""["checked"] | ((???*2* | ???*3*) ? ???*7* : ???*10*)["checked"]) +714 -> 716 conditional = (???*0* | ""["checked"] | ((???*2* | ???*3*) ? ???*7* : ???*10*)["checked"]) - *0* ???*1*["checked"] ⚠️ unknown object - *1* arguments[0] @@ -2603,7 +4831,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* a ⚠️ circular variable reference -0 -> 396 conditional = ((???*0* | "" | ???*1*) !== ???*12*) +709 -> 718 conditional = ((???*0* | "" | ???*1*) !== ???*12*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ((???*2* | ???*3*) ? ???*7* : ???*10*) @@ -2637,7 +4865,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* arguments[0] ⚠️ function calls are not analysed yet -396 -> 398 member call = ( +718 -> 720 member call = ( | ???*0* | ""["_valueTracker"] | ((???*2* | ???*3*) ? ???*7* : ???*10*)["_valueTracker"] @@ -2691,24 +4919,62 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *22* a ⚠️ circular variable reference -0 -> 399 free var = FreeVar(document) +709 -> 721 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 400 conditional = ("undefined" !== ???*0*) +0 -> 722 free var = FreeVar(document) + +0 -> 723 conditional = ("undefined" !== ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(document) ⚠️ unknown global ⚠️ This value might have side effects -400 -> 401 free var = FreeVar(document) +723 -> 724 free var = FreeVar(document) + +0 -> 725 conditional = ("undefined" === ???*0*) +- *0* typeof((???*1* | ???*2* | ???*3*)) + ⚠️ nested operation +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* a + ⚠️ circular variable reference +- *3* (???*4* ? ???*7* : ???*8*) + ⚠️ nested operation +- *4* ("undefined" !== ???*5*) + ⚠️ nested operation +- *5* typeof(???*6*) + ⚠️ nested operation +- *6* FreeVar(document) + ⚠️ unknown global + ⚠️ This value might have side effects +- *7* FreeVar(document) + ⚠️ unknown global + ⚠️ This value might have side effects +- *8* unsupported expression + ⚠️ This value might have side effects + +725 -> 726 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 406 conditional = (null != ???*0*) +725 -> 729 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +725 -> 731 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 733 conditional = (null != ???*0*) - *0* ???*1*["checked"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 409 call = ???*0*( +0 -> 736 call = ???*0*( {}, ???*2*, { @@ -2749,25 +5015,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* arguments[0] ⚠️ function calls are not analysed yet -0 -> 411 conditional = (null == ???*0*) +0 -> 737 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 739 conditional = (null == ???*0*) - *0* ???*1*["defaultValue"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 414 conditional = (null != ???*0*) +0 -> 742 conditional = (null != ???*0*) - *0* ???*1*["checked"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 418 conditional = (null != ???*0*) +0 -> 746 conditional = (null != ???*0*) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 420 call = (...) => (undefined | a | "")((???*0* ? ???*3* : (???*5* | undefined | ""))) +0 -> 748 call = (...) => (undefined | a | "")((???*0* ? ???*3* : (???*5* | undefined | ""))) - *0* (null != ???*1*) ⚠️ nested operation - *1* ???*2*["value"] @@ -2791,7 +5061,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[1] ⚠️ function calls are not analysed yet -0 -> 424 conditional = (("checkbox" === ???*0*) | ("radio" === ???*2*)) +0 -> 752 conditional = (("checkbox" === ???*0*) | ("radio" === ???*2*)) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[1] @@ -2801,7 +5071,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 428 call = (...) => undefined(???*0*, "checked", (???*1* | ???*2*), false) +0 -> 756 call = (...) => undefined(???*0*, "checked", (???*1* | ???*2*), false) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -2811,31 +5081,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* b ⚠️ circular variable reference -0 -> 429 call = (...) => undefined(???*0*, ???*1*) +0 -> 757 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 431 call = (...) => (undefined | a | "")(???*0*) +0 -> 759 call = (...) => (undefined | a | "")(???*0*) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 433 conditional = (null != (undefined | ???*0* | "")) +0 -> 761 conditional = (null != (undefined | ???*0* | "")) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -433 -> 434 conditional = ("number" === ???*0*) +761 -> 762 conditional = ("number" === ???*0*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -434 -> 437 conditional = ((0 === (undefined | ???*0* | "")) | ("" === ???*2*) | (???*4* != (undefined | ???*6* | ""))) +762 -> 765 conditional = ((0 === (undefined | ???*0* | "")) | ("" === ???*2*) | (???*4* != (undefined | ???*6* | ""))) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] @@ -2853,7 +5123,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[1] ⚠️ function calls are not analysed yet -433 -> 441 conditional = (("submit" === ???*0*) | ("reset" === ???*2*)) +761 -> 769 conditional = (("submit" === ???*0*) | ("reset" === ???*2*)) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[1] @@ -2863,21 +5133,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -441 -> 443 member call = ???*0*["removeAttribute"]("value") +769 -> 771 member call = ???*0*["removeAttribute"]("value") - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 445 member call = ???*0*["hasOwnProperty"]("value") +769 -> 772 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 774 member call = ???*0*["hasOwnProperty"]("value") - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 446 conditional = ???*0* +0 -> 775 conditional = ???*0* - *0* ???*1*["hasOwnProperty"]("value") ⚠️ unknown callee object - *1* arguments[1] ⚠️ function calls are not analysed yet -446 -> 448 call = (...) => undefined(???*0*, ???*1*, (undefined | ???*3* | "")) +775 -> 777 call = (...) => undefined(???*0*, ???*1*, (undefined | ???*3* | "")) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["type"] @@ -2889,17 +5163,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -446 -> 450 member call = ???*0*["hasOwnProperty"]("defaultValue") +775 -> 779 member call = ???*0*["hasOwnProperty"]("defaultValue") - *0* arguments[1] ⚠️ function calls are not analysed yet -446 -> 453 call = (...) => (undefined | a | "")(???*0*) +775 -> 782 call = (...) => (undefined | a | "")(???*0*) - *0* ???*1*["defaultValue"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -446 -> 454 call = (...) => undefined(???*0*, ???*1*, (undefined | ???*3* | "")) +775 -> 783 call = (...) => undefined(???*0*, ???*1*, (undefined | ???*3* | "")) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["type"] @@ -2911,7 +5185,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -0 -> 460 member call = (???*0* | ???*1*)["hasOwnProperty"]("value") +0 -> 789 member call = (???*0* | ???*1*)["hasOwnProperty"]("value") - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["initialValue"] @@ -2921,7 +5195,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 462 member call = (???*0* | ???*1*)["hasOwnProperty"]("defaultValue") +0 -> 791 member call = (???*0* | ???*1*)["hasOwnProperty"]("defaultValue") - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["initialValue"] @@ -2931,19 +5205,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 463 conditional = ???*0* +0 -> 792 conditional = ???*0* - *0* ???*1*["hasOwnProperty"]("value") ⚠️ unknown callee object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 479 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])(???*0*) +792 -> 796 conditional = !(???*0*) +- *0* ("submit" !== ???*1*) + ⚠️ nested operation +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +796 -> 797 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 810 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])(???*0*) - *0* ???*1*["ownerDocument"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 480 conditional = (("number" !== ???*0*) | ((undefined | null | ???*1*) !== ???*4*)) +0 -> 811 conditional = (("number" !== ???*0*) | ((undefined | null | ???*1*) !== ???*4*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["activeElement"] @@ -2955,13 +5241,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -480 -> 481 conditional = (null == ???*0*) +811 -> 812 conditional = (null == ???*0*) - *0* arguments[2] ⚠️ function calls are not analysed yet -0 -> 488 free var = FreeVar(Array) +0 -> 819 free var = FreeVar(Array) -0 -> 490 conditional = (???*0* | {} | null | ???*1*) +0 -> 821 conditional = (???*0* | {} | null | ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*[(0 | ???*3* | ???*4*)] @@ -2976,7 +5262,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* b ⚠️ circular variable reference -490 -> 498 member call = (???*0* | {} | null | ???*1*)["hasOwnProperty"](`$${???*6*}`) +821 -> 829 member call = (???*0* | {} | null | ???*1*)["hasOwnProperty"](`$${???*6*}`) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*[(0 | ???*3* | ???*4*)] @@ -3005,7 +5291,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* c ⚠️ circular variable reference -490 -> 505 call = (...) => (undefined | a | "")((???*0* | 0 | ???*1* | undefined | ???*2* | "")) +821 -> 836 call = (...) => (undefined | a | "")((???*0* | 0 | ???*1* | undefined | ???*2* | "")) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* updated with update expression @@ -3013,7 +5299,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* c ⚠️ circular variable reference -490 -> 509 conditional = (???*0* === (???*16* | 0 | ???*17* | undefined | ???*18* | "")) +821 -> 840 conditional = (???*0* === (???*16* | 0 | ???*17* | undefined | ???*18* | "")) - *0* ???*1*["value"] ⚠️ unknown object ⚠️ This value might have side effects @@ -3064,17 +5350,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* c ⚠️ circular variable reference -0 -> 519 conditional = (null != ???*0*) +840 -> 845 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 851 conditional = (null != ???*0*) - *0* ???*1*["dangerouslySetInnerHTML"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -519 -> 520 free var = FreeVar(Error) +851 -> 852 free var = FreeVar(Error) -519 -> 521 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(91) +851 -> 853 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(91) -519 -> 522 call = ???*0*( +851 -> 854 call = ???*0*( `Minified React error #${91}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3083,7 +5373,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${91}` ⚠️ nested operation -0 -> 525 call = ???*0*( +0 -> 857 call = ???*0*( {}, ???*2*, {"value": ???*3*, "defaultValue": ???*4*, "children": ???*5*} @@ -3107,7 +5397,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[0] ⚠️ function calls are not analysed yet -0 -> 527 conditional = (null == (???*0* | ""["value"] | ""["children"] | ???*2* | ???*3* | "")) +0 -> 858 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 860 conditional = (null == (???*0* | ""["value"] | ""["children"] | ???*2* | ???*3* | "")) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] @@ -3117,7 +5411,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -527 -> 530 conditional = (null != (???*0* | ""["value"] | ""["children"] | ???*2* | ???*3* | "")) +860 -> 863 conditional = (null != (???*0* | ""["value"] | ""["children"] | ???*2* | ???*3* | "")) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] @@ -3127,7 +5421,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -530 -> 531 conditional = (null != (???*0* | ???*1* | ???*3* | "")) +863 -> 864 conditional = (null != (???*0* | ???*1* | ???*3* | "")) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["defaultValue"] @@ -3137,11 +5431,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* b ⚠️ circular variable reference -531 -> 532 free var = FreeVar(Error) +864 -> 865 free var = FreeVar(Error) -531 -> 533 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(92) +864 -> 866 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(92) -531 -> 534 call = ???*0*( +864 -> 867 call = ???*0*( `Minified React error #${92}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3150,7 +5444,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${92}` ⚠️ nested operation -530 -> 535 call = ???*0*( +863 -> 868 call = ???*0*( (???*2* | ""["value"] | ""["children"] | ???*4* | ???*5* | "") ) - *0* ???*1*["isArray"] @@ -3168,7 +5462,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* c ⚠️ circular variable reference -530 -> 536 conditional = ???*0* +863 -> 869 conditional = ???*0* - *0* ???*1*(c) ⚠️ unknown callee ⚠️ This value might have side effects @@ -3179,11 +5473,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -536 -> 538 free var = FreeVar(Error) +869 -> 871 free var = FreeVar(Error) -536 -> 539 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(93) +869 -> 872 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(93) -536 -> 540 call = ???*0*( +869 -> 873 call = ???*0*( `Minified React error #${93}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3192,7 +5486,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${93}` ⚠️ nested operation -0 -> 543 call = (...) => (undefined | a | "")( +0 -> 876 call = (...) => (undefined | a | "")( (???*0* | ""["value"] | ""["children"] | ???*2* | ???*3* | "") ) - *0* ???*1*["value"] @@ -3204,25 +5498,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -0 -> 545 call = (...) => (undefined | a | "")(???*0*) +0 -> 878 call = (...) => (undefined | a | "")(???*0*) - *0* ???*1*["value"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 547 call = (...) => (undefined | a | "")(???*0*) +0 -> 880 call = (...) => (undefined | a | "")(???*0*) - *0* ???*1*["defaultValue"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 558 conditional = ((null == ???*0*) | ("http://www.w3.org/1999/xhtml" === ???*1*)) +0 -> 891 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 892 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 893 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 894 conditional = ((null == ???*0*) | ("http://www.w3.org/1999/xhtml" === ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -558 -> 559 call = (...) => ( +894 -> 895 call = (...) => ( | undefined | "http://www.w3.org/2000/svg" | "http://www.w3.org/1998/Math/MathML" @@ -3231,17 +5537,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *0* arguments[1] ⚠️ function calls are not analysed yet -558 -> 560 conditional = (("http://www.w3.org/2000/svg" === ???*0*) | ("foreignObject" === ???*1*)) +894 -> 896 conditional = (("http://www.w3.org/2000/svg" === ???*0*) | ("foreignObject" === ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 561 free var = FreeVar(MSApp) +0 -> 897 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 898 free var = FreeVar(MSApp) -0 -> 563 free var = FreeVar(MSApp) +0 -> 900 free var = FreeVar(MSApp) -0 -> 564 conditional = (("undefined" !== ???*0*) | ???*2*) +0 -> 901 conditional = (("undefined" !== ???*0*) | ???*2*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(MSApp) @@ -3254,14 +5564,14 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -564 -> 566 free var = FreeVar(MSApp) +901 -> 903 free var = FreeVar(MSApp) -564 -> 567 member call = ???*0*["execUnsafeLocalFunction"]((...) => a(b, c, d, e)) +901 -> 904 member call = ???*0*["execUnsafeLocalFunction"]((...) => a(b, c, d, e)) - *0* FreeVar(MSApp) ⚠️ unknown global ⚠️ This value might have side effects -567 -> 568 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +904 -> 905 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -3271,7 +5581,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -0 -> 570 conditional = (("http://www.w3.org/2000/svg" !== ???*0*) | ???*2*) +904 -> 906 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 907 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 909 conditional = (("http://www.w3.org/2000/svg" !== ???*0*) | ???*2*) - *0* ???*1*["namespaceURI"] ⚠️ unknown object - *1* arguments[0] @@ -3279,14 +5597,14 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -570 -> 573 free var = FreeVar(document) +909 -> 912 free var = FreeVar(document) -570 -> 574 member call = ???*0*["createElement"]("div") +909 -> 913 member call = ???*0*["createElement"]("div") - *0* FreeVar(document) ⚠️ unknown global ⚠️ This value might have side effects -570 -> 578 member call = (???*0* | ???*1* | ???*3*)["valueOf"]() +909 -> 917 member call = (???*0* | ???*1* | ???*3*)["valueOf"]() - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["firstChild"] @@ -3303,7 +5621,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -570 -> 579 member call = (???*0*() | ???*2*())["toString"]() +909 -> 918 member call = (???*0*() | ???*2*())["toString"]() - *0* ???*1*["valueOf"] ⚠️ unknown object - *1* arguments[1] @@ -3321,7 +5639,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -570 -> 584 member call = ???*0*["removeChild"](???*1*) +909 -> 923 member call = ???*0*["removeChild"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["firstChild"] @@ -3329,7 +5647,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -570 -> 588 member call = ???*0*["appendChild"]((???*1* | ???*3*)) +909 -> 927 member call = ???*0*["appendChild"]((???*1* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["firstChild"] @@ -3349,11 +5667,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 589 conditional = ???*0* +0 -> 928 conditional = ???*0* - *0* arguments[1] ⚠️ function calls are not analysed yet -589 -> 593 conditional = (???*0* | (???*2* === ???*4*) | (3 === ???*6*)) +928 -> 932 conditional = (???*0* | (???*2* === ???*4*) | (3 === ???*6*)) - *0* ???*1*["firstChild"] ⚠️ unknown object - *1* arguments[0] @@ -3373,9 +5691,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[0] ⚠️ function calls are not analysed yet -0 -> 598 free var = FreeVar(Object) +932 -> 934 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 938 free var = FreeVar(Object) -0 -> 599 member call = ???*0*["keys"]( +0 -> 939 member call = ???*0*["keys"]( { "animationIterationCount": true, "aspectRatio": true, @@ -3426,7 +5748,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 600 member call = ???*0*["forEach"]((...) => undefined) +0 -> 940 member call = ???*0*["forEach"]((...) => undefined) - *0* ???*1*["keys"](pb) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -3434,23 +5756,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -600 -> 602 member call = ["Webkit", "ms", "Moz", "O"]["forEach"]((...) => undefined) +940 -> 942 member call = ["Webkit", "ms", "Moz", "O"]["forEach"]((...) => undefined) -602 -> 605 member call = ???*0*["charAt"](0) +942 -> 945 member call = ???*0*["charAt"](0) - *0* arguments[0] ⚠️ function calls are not analysed yet -602 -> 606 member call = ???*0*["toUpperCase"]() +942 -> 946 member call = ???*0*["toUpperCase"]() - *0* ???*1*["charAt"](0) ⚠️ unknown callee object - *1* arguments[0] ⚠️ function calls are not analysed yet -602 -> 608 member call = ???*0*["substring"](1) +942 -> 948 member call = ???*0*["substring"](1) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 611 conditional = ((null == ???*0*) | ("boolean" === ???*1*) | ("" === ???*3*)) +0 -> 951 conditional = ((null == ???*0*) | ("boolean" === ???*1*) | ("" === ???*3*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* typeof(???*2*) @@ -3460,7 +5782,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -611 -> 613 member call = { +951 -> 953 member call = { "animationIterationCount": true, "aspectRatio": true, "borderImageOutset": true, @@ -3508,7 +5830,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *0* arguments[0] ⚠️ function calls are not analysed yet -611 -> 615 conditional = (???*0* | ("number" !== ???*1*) | (0 === ???*3*) | ???*4* | true | ???*8*) +951 -> 955 conditional = (???*0* | ("number" !== ???*1*) | (0 === ???*3*) | ???*4* | true | ???*8*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* typeof(???*2*) @@ -3532,27 +5854,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[0] ⚠️ function calls are not analysed yet -615 -> 617 member call = ???*0*["trim"]() +955 -> 957 member call = ???*0*["trim"]() - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 620 member call = ???*0*["hasOwnProperty"]((???*1* | "cssFloat")) +0 -> 958 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 961 member call = ???*0*["hasOwnProperty"]((???*1* | "cssFloat")) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* c ⚠️ pattern without value -0 -> 621 conditional = ???*0* +0 -> 962 conditional = ???*0* - *0* ???*1*["hasOwnProperty"](c) ⚠️ unknown callee object - *1* arguments[1] ⚠️ function calls are not analysed yet -621 -> 623 member call = (???*0* | "cssFloat")["indexOf"]("--") +962 -> 964 member call = (???*0* | "cssFloat")["indexOf"]("--") - *0* c ⚠️ pattern without value -621 -> 625 call = (...) => (((null == b) || ("boolean" === typeof(b)) || ("" === b)) ? "" : ((c || ("number" !== typeof(b)) || (0 === b) || (pb["hasOwnProperty"](a) && pb[a])) ? `${b}`["trim"]() : `${b}px`))((???*0* | "cssFloat"), ???*1*, (0 === (???*3* | ???*5*))) +962 -> 966 call = (...) => (((null == b) || ("boolean" === typeof(b)) || ("" === b)) ? "" : ((c || ("number" !== typeof(b)) || (0 === b) || (pb["hasOwnProperty"](a) && pb[a])) ? `${b}`["trim"]() : `${b}px`))((???*0* | "cssFloat"), ???*1*, (0 === (???*3* | ???*5*))) - *0* c ⚠️ pattern without value - *1* ???*2*[c] @@ -3566,7 +5892,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* "cssFloat"["indexOf"]("--") ⚠️ nested operation -621 -> 626 conditional = (0 === (???*0* | ???*2*)) +962 -> 967 conditional = (0 === (???*0* | ???*2*)) - *0* ???*1*["indexOf"]("--") ⚠️ unknown callee object - *1* c @@ -3574,7 +5900,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* "cssFloat"["indexOf"]("--") ⚠️ nested operation -626 -> 628 member call = (???*0* | ???*1*)["setProperty"]((???*3* | "cssFloat"), ???*4*) +967 -> 969 member call = (???*0* | ???*1*)["setProperty"]((???*3* | "cssFloat"), ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["style"] @@ -3586,7 +5912,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -0 -> 630 call = ???*0*( +0 -> 971 call = ???*0*( {"menuitem": true}, { "area": true, @@ -3613,11 +5939,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 631 conditional = ???*0* +0 -> 972 conditional = ???*0* - *0* arguments[1] ⚠️ function calls are not analysed yet -631 -> 635 conditional = (???*0* | (null != ???*4*)) +972 -> 976 conditional = (???*0* | (null != ???*4*)) - *0* ???*1*[a] ⚠️ unknown object ⚠️ This value might have side effects @@ -3654,13 +5980,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[1] ⚠️ function calls are not analysed yet -635 -> 636 free var = FreeVar(Error) +976 -> 977 free var = FreeVar(Error) -635 -> 637 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(137, ???*0*) +976 -> 978 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(137, ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -635 -> 638 call = ???*0*( +976 -> 979 call = ???*0*( `Minified React error #${137}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3669,23 +5995,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${137}` ⚠️ nested operation -631 -> 640 conditional = (null != ???*0*) +972 -> 981 conditional = (null != ???*0*) - *0* ???*1*["dangerouslySetInnerHTML"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -640 -> 642 conditional = (null != ???*0*) +981 -> 983 conditional = (null != ???*0*) - *0* ???*1*["children"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -642 -> 643 free var = FreeVar(Error) +983 -> 984 free var = FreeVar(Error) -642 -> 644 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(60) +983 -> 985 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(60) -642 -> 645 call = ???*0*( +983 -> 986 call = ???*0*( `Minified React error #${60}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3694,7 +6020,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${60}` ⚠️ nested operation -640 -> 648 conditional = (("object" !== ???*0*) | !(???*3*)) +981 -> 989 conditional = (("object" !== ???*0*) | !(???*3*)) - *0* typeof(???*1*) ⚠️ nested operation - *1* ???*2*["dangerouslySetInnerHTML"] @@ -3704,11 +6030,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -648 -> 649 free var = FreeVar(Error) +989 -> 990 free var = FreeVar(Error) -648 -> 650 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(61) +989 -> 991 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(61) -648 -> 651 call = ???*0*( +989 -> 992 call = ???*0*( `Minified React error #${61}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3717,7 +6043,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${61}` ⚠️ nested operation -631 -> 654 conditional = ((null != ???*0*) | ("object" !== ???*2*)) +972 -> 995 conditional = ((null != ???*0*) | ("object" !== ???*2*)) - *0* ???*1*["style"] ⚠️ unknown object - *1* arguments[1] @@ -3729,11 +6055,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -654 -> 655 free var = FreeVar(Error) +995 -> 996 free var = FreeVar(Error) -654 -> 656 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(62) +995 -> 997 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(62) -654 -> 657 call = ???*0*( +995 -> 998 call = ???*0*( `Minified React error #${62}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3742,11 +6068,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${62}` ⚠️ nested operation -0 -> 659 member call = ???*0*["indexOf"]("-") +0 -> 1000 member call = ???*0*["indexOf"]("-") - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 660 conditional = (???*0* === ???*1*) +0 -> 1001 conditional = (???*0* === ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["indexOf"]("-") @@ -3754,9 +6080,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 664 free var = FreeVar(window) +1001 -> 1003 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1001 -> 1004 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 668 conditional = (3 === (???*0* | ???*2*)) +1001 -> 1005 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1008 free var = FreeVar(window) + +0 -> 1012 conditional = (3 === (???*0* | ???*2*)) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[0] @@ -3768,7 +6106,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 670 call = (...) => (( +0 -> 1014 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1015 call = (...) => (( || !(a) || ((5 !== a["tag"]) && (6 !== a["tag"]) && (13 !== a["tag"]) && (3 !== a["tag"])) ) ? null : a)((???*0* | (???*1* ? null : (???*5* | ???*6*)))) @@ -3789,15 +6131,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* a ⚠️ circular variable reference -0 -> 671 conditional = ("function" !== ???*0*) +0 -> 1016 conditional = ("function" !== ???*0*) - *0* typeof((null | (...) => undefined)) ⚠️ nested operation -671 -> 672 free var = FreeVar(Error) +1016 -> 1017 free var = FreeVar(Error) -671 -> 673 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(280) +1016 -> 1018 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(280) -671 -> 674 call = ???*0*( +1016 -> 1019 call = ???*0*( `Minified React error #${280}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -3806,7 +6148,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${280}` ⚠️ nested operation -0 -> 676 call = (...) => (a[Pf] || null)( +0 -> 1021 call = (...) => (a[Pf] || null)( (???*0* | (???*2* ? null : (???*6* | ???*7*))["stateNode"] | null) ) - *0* ???*1*["stateNode"] @@ -3828,7 +6170,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* a ⚠️ circular variable reference -0 -> 679 call = (null | (...) => undefined)( +0 -> 1024 call = (null | (...) => undefined)( (???*0* | (???*2* ? null : (???*6* | ???*7*))["stateNode"]), (???*9* | (???*11* ? null : (???*15* | ???*16*))["type"]), ( @@ -3892,17 +6234,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* a ⚠️ circular variable reference -0 -> 680 conditional = (null | ???*0*) +0 -> 1025 conditional = (null | ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -680 -> 681 conditional = (null | [???*0*] | ???*1*) +1025 -> 1026 conditional = (null | [???*0*] | ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression ⚠️ This value might have side effects -681 -> 683 member call = (null | [???*0*] | ???*1*)["push"](???*2*) +1026 -> 1028 member call = (null | [???*0*] | ???*1*)["push"](???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -3910,23 +6252,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 684 conditional = (null | ???*0*) +0 -> 1029 conditional = (null | ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -684 -> 685 call = (...) => undefined((null | ???*0* | 0 | ???*1*)) +1029 -> 1030 call = (...) => undefined((null | ???*0* | 0 | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* updated with update expression ⚠️ This value might have side effects -684 -> 686 conditional = (null | [???*0*] | ???*1*) +1029 -> 1031 conditional = (null | [???*0*] | ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression ⚠️ This value might have side effects -686 -> 689 call = (...) => undefined( +1031 -> 1034 call = (...) => undefined( (null[(null | ???*0* | 0 | ???*1*)] | ???*2* | ???*4* | ???*5* | ???*7* | ???*8*) ) - *0* arguments[0] @@ -3955,15 +6297,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* updated with update expression ⚠️ This value might have side effects -0 -> 690 call = ???*0*(???*1*) +0 -> 1035 call = ???*0*(???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 691 conditional = (false | true) +0 -> 1036 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1037 conditional = (false | true) -691 -> 692 call = ???*0*(???*1*, ???*2*) +1037 -> 1038 call = ???*0*(???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -3971,7 +6317,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -0 -> 693 call = ((...) => a(b) | (...) => (undefined | a(b)))(???*0*, ???*1*, ???*2*) +1037 -> 1039 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1037 -> 1040 call = ((...) => a(b) | (...) => (undefined | a(b)))(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -3979,11 +6329,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -0 -> 694 call = ((...) => undefined | (...) => (undefined | a()))() +1037 -> 1041 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1037 -> 1042 call = ((...) => undefined | (...) => (undefined | a()))() + +1037 -> 1043 call = (...) => undefined() + +0 -> 1045 conditional = (null === (???*0* | false["stateNode"] | null[???*2*])) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* arguments[1] + ⚠️ function calls are not analysed yet -0 -> 695 call = (...) => undefined() +1045 -> 1046 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 697 call = (...) => (a[Pf] || null)( +1045 -> 1047 call = (...) => (a[Pf] || null)( ( | ???*0* | !((???*2* | null | ???*4*))["stateNode"] @@ -4030,7 +6396,67 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* arguments[1] ⚠️ function calls are not analysed yet -0 -> 701 conditional = ( +1045 -> 1048 conditional = (null === (???*0* | false["stateNode"][???*7*] | null | ???*12*)) +- *0* ???*1*[`__reactProps$${???*3*}`] + ⚠️ unknown object +- *1* ???*2*["stateNode"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["slice"](2) + ⚠️ unknown callee object +- *4* ???*5*(36) + ⚠️ unknown callee +- *5* ???*6*["toString"] + ⚠️ unknown object +- *6* ???() + ⚠️ nested operation +- *7* `__reactProps$${???*8*}` + ⚠️ nested operation +- *8* ???*9*["slice"](2) + ⚠️ unknown callee object +- *9* ???*10*(36) + ⚠️ unknown callee +- *10* ???*11*["toString"] + ⚠️ unknown object +- *11* ???() + ⚠️ nested operation +- *12* !(???*13*) + ⚠️ nested operation +- *13* ???*14*["disabled"] + ⚠️ unknown object +- *14* d + ⚠️ circular variable reference + +1048 -> 1049 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1048 -> 1053 conditional = (???*0* | ???*1* | !((???*3* | null | ???*6*)) | false) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference +- *3* ???*4*[Pf] + ⚠️ unknown object +- *4* ???*5*["stateNode"] + ⚠️ unknown object +- *5* a + ⚠️ circular variable reference +- *6* !(???*7*) + ⚠️ nested operation +- *7* ???*8*["disabled"] + ⚠️ unknown object +- *8* d + ⚠️ circular variable reference + +1053 -> 1054 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1053 -> 1055 conditional = ( | ???*0* | !((???*2* | null | ???*4*))["stateNode"] | false["stateNode"] @@ -4084,9 +6510,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* arguments[1] ⚠️ function calls are not analysed yet -701 -> 702 free var = FreeVar(Error) +1055 -> 1056 free var = FreeVar(Error) -701 -> 703 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`( +1055 -> 1057 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`( 231, ???*0*, typeof((???*1* | false["stateNode"] | null[???*3*])) @@ -4100,7 +6526,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -701 -> 704 call = ???*0*( +1055 -> 1058 call = ???*0*( `Minified React error #${231}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4109,7 +6535,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${231}` ⚠️ nested operation -0 -> 705 conditional = !(???*0*) +1053 -> 1059 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1060 conditional = !(???*0*) - *0* ("undefined" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -4118,32 +6548,32 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -705 -> 707 free var = FreeVar(Object) +1060 -> 1062 free var = FreeVar(Object) -705 -> 708 member call = ???*0*["defineProperty"]({}, "passive", {"get": (...) => undefined}) +1060 -> 1063 member call = ???*0*["defineProperty"]({}, "passive", {"get": (...) => undefined}) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects -705 -> 710 free var = FreeVar(window) +1060 -> 1065 free var = FreeVar(window) -705 -> 711 member call = ???*0*["addEventListener"]("test", {}, {}) +1060 -> 1066 member call = ???*0*["addEventListener"]("test", {}, {}) - *0* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -705 -> 713 free var = FreeVar(window) +1060 -> 1068 free var = FreeVar(window) -705 -> 714 member call = ???*0*["removeEventListener"]("test", {}, {}) +1060 -> 1069 member call = ???*0*["removeEventListener"]("test", {}, {}) - *0* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 718 free var = FreeVar(Array) +0 -> 1073 free var = FreeVar(Array) -0 -> 719 free var = FreeVar(arguments) +0 -> 1074 free var = FreeVar(arguments) -0 -> 720 member call = ???*0*["call"](???*3*, 3) +0 -> 1075 member call = ???*0*["call"](???*3*, 3) - *0* ???*1*["slice"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4157,7 +6587,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 722 member call = ???*0*["apply"](???*1*, ???*2*) +0 -> 1077 member call = ???*0*["apply"](???*1*, ???*2*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -4175,37 +6605,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 724 member call = ???*0*["onError"](???*1*) +0 -> 1079 member call = ???*0*["onError"](???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* m ⚠️ pattern without value -0 -> 726 free var = FreeVar(arguments) +0 -> 1081 free var = FreeVar(arguments) -0 -> 727 member call = (...) => undefined["apply"]({"onError": (...) => undefined}, ???*0*) +0 -> 1082 member call = (...) => undefined["apply"]({"onError": (...) => undefined}, ???*0*) - *0* FreeVar(arguments) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 729 free var = FreeVar(arguments) +0 -> 1084 free var = FreeVar(arguments) -0 -> 730 member call = (...) => undefined["apply"](???*0*, ???*1*) +0 -> 1085 member call = (...) => undefined["apply"](???*0*, ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* FreeVar(arguments) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 731 conditional = (false | true) +0 -> 1086 conditional = (false | true) -731 -> 732 conditional = (false | true) +1086 -> 1087 conditional = (false | true) -732 -> 733 free var = FreeVar(Error) +1087 -> 1088 free var = FreeVar(Error) -732 -> 734 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(198) +1087 -> 1089 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(198) -732 -> 735 call = ???*0*( +1087 -> 1090 call = ???*0*( `Minified React error #${198}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4214,35 +6644,47 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${198}` ⚠️ nested operation -0 -> 737 conditional = ???*0* +0 -> 1092 conditional = ???*0* - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 744 conditional = (3 === ???*0*) +0 -> 1099 conditional = (3 === ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 746 conditional = (13 === ???*0*) +0 -> 1100 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1102 conditional = (13 === ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -746 -> 750 conditional = (null !== ???*0*) +1102 -> 1106 conditional = (null !== ???*0*) - *0* ???*1*["memoizedState"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 752 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) +1106 -> 1108 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1109 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1110 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 753 conditional = (???*0* !== ???*8*) +0 -> 1111 conditional = (???*0* !== ???*8*) - *0* (???*1* ? (???*4* | ???*5* | ???*6*) : null) ⚠️ nested operation - *1* (3 === ???*2*) @@ -4262,11 +6704,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[0] ⚠️ function calls are not analysed yet -753 -> 754 free var = FreeVar(Error) +1111 -> 1112 free var = FreeVar(Error) -753 -> 755 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) +1111 -> 1113 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) -753 -> 756 call = ???*0*( +1111 -> 1114 call = ???*0*( `Minified React error #${188}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4275,7 +6717,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${188}` ⚠️ nested operation -0 -> 758 conditional = !((???*0* | ???*2*)) +0 -> 1116 conditional = !((???*0* | ???*2*)) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] @@ -4297,11 +6739,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* b ⚠️ circular variable reference -758 -> 759 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) +1116 -> 1117 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -758 -> 760 conditional = (null === (???*0* | ???*2*)) +1116 -> 1118 conditional = (null === (???*0* | ???*2*)) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] @@ -4323,11 +6765,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* b ⚠️ circular variable reference -760 -> 761 free var = FreeVar(Error) +1118 -> 1119 free var = FreeVar(Error) -760 -> 762 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) +1118 -> 1120 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) -760 -> 763 call = ???*0*( +1118 -> 1121 call = ???*0*( `Minified React error #${188}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4336,7 +6778,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${188}` ⚠️ nested operation -758 -> 764 conditional = ((???*0* | ???*2*) !== ???*10*) +1116 -> 1122 conditional = ((???*0* | ???*2*) !== ???*10*) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] @@ -4360,7 +6802,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[0] ⚠️ function calls are not analysed yet -0 -> 767 conditional = (null === ???*0*) +1116 -> 1123 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1116 -> 1126 conditional = (null === ???*0*) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* ???*2*["return"] @@ -4368,7 +6814,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 771 conditional = (???*0* === ???*3*) +1116 -> 1130 conditional = (???*0* === ???*3*) - *0* ???*1*["child"] ⚠️ unknown object - *1* ???*2*["return"] @@ -4384,7 +6830,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -771 -> 773 conditional = (???*0* === (???*3* | ???*4* | ???*6*)) +1130 -> 1132 conditional = (???*0* === (???*3* | ???*4* | ???*6*)) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* ???*2*["return"] @@ -4414,7 +6860,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* b ⚠️ circular variable reference -773 -> 774 call = (...) => undefined( +1132 -> 1133 call = (...) => undefined( ( | ???*0* | (???*2* ? (???*5* | ???*6* | ???*7*) : null)["return"] @@ -4439,7 +6885,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* b ⚠️ circular variable reference -771 -> 775 conditional = (???*0* === (???*3* | ???*5*)) +1132 -> 1134 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1132 -> 1135 conditional = (???*0* === (???*3* | ???*5*)) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* ???*2*["return"] @@ -4467,7 +6917,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* b ⚠️ circular variable reference -775 -> 776 call = (...) => undefined( +1135 -> 1136 call = (...) => undefined( ( | ???*0* | (???*2* ? (???*5* | ???*6* | ???*7*) : null)["return"] @@ -4492,11 +6942,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* b ⚠️ circular variable reference -771 -> 778 free var = FreeVar(Error) +1135 -> 1137 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1130 -> 1139 free var = FreeVar(Error) -771 -> 779 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) +1130 -> 1140 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) -771 -> 780 call = ???*0*( +1130 -> 1141 call = ???*0*( `Minified React error #${188}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4505,7 +6959,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${188}` ⚠️ nested operation -0 -> 783 conditional = (???*0* !== ???*2*) +1116 -> 1144 conditional = (???*0* !== ???*2*) - *0* ???*1*["return"] ⚠️ unknown object - *1* arguments[0] @@ -4517,15 +6971,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -783 -> 786 conditional = !((false | true)) +1144 -> 1147 conditional = !((false | true)) -786 -> 789 conditional = !((false | true)) +1147 -> 1150 conditional = !((false | true)) -789 -> 790 free var = FreeVar(Error) +1150 -> 1151 free var = FreeVar(Error) -789 -> 791 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(189) +1150 -> 1152 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(189) -789 -> 792 call = ???*0*( +1150 -> 1153 call = ???*0*( `Minified React error #${189}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4534,7 +6988,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${189}` ⚠️ nested operation -0 -> 794 conditional = (???*0* !== (???*2* | ???*4*)) +1116 -> 1155 conditional = (???*0* !== (???*2* | ???*4*)) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] @@ -4560,11 +7014,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* b ⚠️ circular variable reference -794 -> 795 free var = FreeVar(Error) +1155 -> 1156 free var = FreeVar(Error) -794 -> 796 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(190) +1155 -> 1157 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(190) -794 -> 797 call = ???*0*( +1155 -> 1158 call = ???*0*( `Minified React error #${190}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4573,17 +7027,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${190}` ⚠️ nested operation -0 -> 799 conditional = (3 !== ???*0*) +0 -> 1160 conditional = (3 !== ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -799 -> 800 free var = FreeVar(Error) +1160 -> 1161 free var = FreeVar(Error) -799 -> 801 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) +1160 -> 1162 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) -799 -> 802 call = ???*0*( +1160 -> 1163 call = ???*0*( `Minified React error #${188}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -4592,7 +7046,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${188}` ⚠️ nested operation -0 -> 805 conditional = (???*0* === (???*3* | ???*4* | ???*6*)) +0 -> 1166 conditional = (???*0* === (???*3* | ???*4* | ???*6*)) - *0* ???*1*["current"] ⚠️ unknown object - *1* ???*2*["stateNode"] @@ -4622,27 +7076,67 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* b ⚠️ circular variable reference -0 -> 806 call = (...) => (((b !== a) ? null : a) | a | b | ((c["stateNode"]["current"] === c) ? a : b))(???*0*) +0 -> 1167 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1168 call = (...) => (((b !== a) ? null : a) | a | b | ((c["stateNode"]["current"] === c) ? a : b))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 807 conditional = ???*0* +0 -> 1169 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -807 -> 808 call = (...) => (a | b | null)(???*0*) +1169 -> 1170 call = (...) => (a | b | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 812 call = (...) => (a | b | null)((???*0* | ???*1*)) +0 -> 1171 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1174 conditional = ((5 === ???*0*) | (6 === ???*2*)) +- *0* ???*1*["tag"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["tag"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +1174 -> 1175 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1174 -> 1177 call = (...) => (a | b | null)((???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["child"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference + +1174 -> 1178 conditional = (null !== (???*0* | ???*1* | ???*3* | null)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] ⚠️ unknown object - *2* a ⚠️ circular variable reference +- *3* b + ⚠️ circular variable reference + +1178 -> 1179 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1181 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 826 conditional = (null | ???*0* | ("function" === ???*1*)) +0 -> 1194 conditional = (null | ???*0* | ("function" === ???*1*)) - *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) ⚠️ unknown global ⚠️ This value might have side effects @@ -4655,7 +7149,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -826 -> 830 member call = (null | ???*0*)["onCommitFiberRoot"]((null | ???*1*), ???*3*, ???*4*, (128 === ???*5*)) +1194 -> 1198 member call = (null | ???*0*)["onCommitFiberRoot"]((null | ???*1*), ???*3*, ???*4*, (128 === ???*5*)) - *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) ⚠️ unknown global ⚠️ This value might have side effects @@ -4672,9 +7166,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unsupported expression ⚠️ This value might have side effects -0 -> 832 free var = FreeVar(Math) +0 -> 1200 free var = FreeVar(Math) -0 -> 833 conditional = ???*0* +0 -> 1201 conditional = ???*0* - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4682,19 +7176,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -833 -> 835 free var = FreeVar(Math) +1201 -> 1203 free var = FreeVar(Math) -0 -> 837 free var = FreeVar(Math) +0 -> 1205 free var = FreeVar(Math) -0 -> 839 free var = FreeVar(Math) +0 -> 1207 free var = FreeVar(Math) -0 -> 840 conditional = (0 === (???*0* | ???*1*)) +0 -> 1208 conditional = (0 === (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported assign operation ⚠️ This value might have side effects -840 -> 841 call = ???*0*((???*2* | ???*3*)) +1208 -> 1209 call = ???*0*((???*2* | ???*3*)) - *0* ???*1*["log"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4706,21 +7200,89 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported assign operation ⚠️ This value might have side effects -0 -> 845 conditional = (0 !== ???*0*) +0 -> 1210 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1211 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1212 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1213 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1214 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1215 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1216 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1217 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1218 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1219 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1220 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1221 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1222 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1223 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1225 conditional = (0 === (???*0* | ???*2*)) +- *0* ???*1*["pendingLanes"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unsupported expression + ⚠️ This value might have side effects + +1225 -> 1226 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1225 -> 1229 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -845 -> 846 conditional = (0 !== ???*0*) +1229 -> 1230 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -846 -> 847 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)(???*1*) +1230 -> 1231 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -846 -> 848 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)((???*1* | ???*3* | ???*4*)) +1230 -> 1232 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)((???*1* | ???*3* | ???*4*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["pingedLanes"] @@ -4732,17 +7294,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -845 -> 849 conditional = (0 !== ???*0*) +1229 -> 1233 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -849 -> 850 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)(???*1*) +1233 -> 1234 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -849 -> 851 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)((???*1* | ???*3* | ???*4*)) +1233 -> 1235 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)((???*1* | ???*3* | ???*4*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["pingedLanes"] @@ -4754,7 +7316,97 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -0 -> 853 conditional = (0 !== (???*0* | ???*1* | ???*3*)) +1225 -> 1236 conditional = (0 === ( + | 0 + | undefined + | 1 + | 2 + | 4 + | 8 + | 16 + | 32 + | ???*0* + | 134217728 + | 268435456 + | 536870912 + | 1073741824 + | ???*1* + | ???*3* +)) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* ???*2*["pingedLanes"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* unsupported assign operation + ⚠️ This value might have side effects + +1236 -> 1237 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1236 -> 1238 conditional = ( + | (0 !== (???*0* | ???*1* | ???*3*)) + | ((???*4* | ???*5* | ???*7*) !== ( + | 0 + | undefined + | 1 + | 2 + | 4 + | 8 + | 16 + | 32 + | ???*8* + | 134217728 + | 268435456 + | 536870912 + | 1073741824 + | ???*9* + | ???*11* + )) + | (0 === ???*12*) + | ???*13* +) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* ???*2*["entangledLanes"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* unsupported assign operation + ⚠️ This value might have side effects +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* ???*6*["entangledLanes"] + ⚠️ unknown object +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* unsupported assign operation + ⚠️ This value might have side effects +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* ???*10*["pingedLanes"] + ⚠️ unknown object +- *10* arguments[0] + ⚠️ function calls are not analysed yet +- *11* unsupported assign operation + ⚠️ This value might have side effects +- *12* unsupported expression + ⚠️ This value might have side effects +- *13* (???*14* || ((16 === e) && (0 !== ???*15*))) + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *14* unsupported expression + ⚠️ This value might have side effects +- *15* unsupported expression + ⚠️ This value might have side effects + +1238 -> 1239 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1238 -> 1241 conditional = (0 !== (???*0* | ???*1* | ???*3*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["entangledLanes"] @@ -4764,7 +7416,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported assign operation ⚠️ This value might have side effects -853 -> 855 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7* | ???*9*)) +1241 -> 1243 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7* | ???*9*)) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4790,7 +7442,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* unsupported assign operation ⚠️ This value might have side effects -0 -> 861 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*8*)) +1238 -> 1245 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1246 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1247 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1248 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1249 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1250 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1255 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*8*)) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4814,7 +7490,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unsupported assign operation ⚠️ This value might have side effects -0 -> 863 conditional = (???*0* === ???*1*) +0 -> 1257 conditional = (???*0* === ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*[g] @@ -4824,13 +7500,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -863 -> 864 conditional = ((0 === ???*0*) | (0 !== ???*1*)) +1257 -> 1258 conditional = ((0 === ???*0*) | (0 !== ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -864 -> 866 call = (...) => (undefined | (b + 250) | (b + 5000) | ???*0*)(???*1*, ???*2*) +1258 -> 1260 call = (...) => (undefined | (b + 250) | (b + 5000) | ???*0*)(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -4838,17 +7514,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 869 conditional = (0 !== (???*0* | ???*1*)) +0 -> 1263 conditional = (0 !== (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression ⚠️ This value might have side effects -0 -> 871 member call = []["push"](???*0*) +0 -> 1264 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1265 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1267 member call = []["push"](???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 876 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) +0 -> 1268 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1273 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4870,7 +7558,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported expression ⚠️ This value might have side effects -0 -> 888 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) +0 -> 1285 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4892,7 +7580,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported assign operation ⚠️ This value might have side effects -0 -> 894 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) +0 -> 1291 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -4914,17 +7602,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported assign operation ⚠️ This value might have side effects -0 -> 897 conditional = (0 !== ???*0*) +0 -> 1294 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 898 free var = FreeVar(Map) +0 -> 1295 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1296 free var = FreeVar(Map) -0 -> 899 free var = FreeVar(Map) +0 -> 1297 free var = FreeVar(Map) -0 -> 901 member call = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit"["split"](" ") +0 -> 1299 member call = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit"["split"](" ") -0 -> 904 member call = ???*0*["delete"](???*1*) +0 -> 1302 member call = ???*0*["delete"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* ???*2*["pointerId"] @@ -4932,7 +7624,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 907 member call = ???*0*["delete"](???*1*) +0 -> 1305 member call = ???*0*["delete"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* ???*2*["pointerId"] @@ -4940,7 +7632,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 909 conditional = ( +0 -> 1307 conditional = ( | (null === ( | ???*0* | { @@ -4996,7 +7688,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *20* arguments[5] ⚠️ function calls are not analysed yet -909 -> 910 call = (...) => (( +1307 -> 1308 call = (...) => (( || !(a) || ((5 !== a["tag"]) && (6 !== a["tag"]) && (13 !== a["tag"]) && (3 !== a["tag"])) ) ? null : a)( @@ -5027,7 +7719,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* unknown mutation ⚠️ This value might have side effects -909 -> 911 call = (???*0* | (...) => undefined)( +1307 -> 1309 call = (???*0* | (...) => undefined)( (???*1* | (???*2* ? null : (???*6* | ???*7*)) | ???*9* | [???*11*] | ???*12*) ) - *0* Fc @@ -5057,7 +7749,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* unknown mutation ⚠️ This value might have side effects -0 -> 915 member call = (???*0* | (???*1* ? null : (???*5* | ???*6*)) | ???*8* | [???*10*] | ???*11*)["indexOf"](???*12*) +1307 -> 1310 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1307 -> 1314 member call = (???*0* | (???*1* ? null : (???*5* | ???*6*)) | ???*8* | [???*10*] | ???*11*)["indexOf"](???*12*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* !((???*2* | ???*3*)) @@ -5085,7 +7781,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[4] ⚠️ function calls are not analysed yet -0 -> 917 member call = (???*0* | (???*1* ? null : (???*5* | ???*6*)) | ???*8* | [???*10*] | ???*11*)["push"](???*12*) +1307 -> 1316 member call = (???*0* | (???*1* ? null : (???*5* | ???*6*)) | ???*8* | [???*10*] | ???*11*)["push"](???*12*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* !((???*2* | ???*3*)) @@ -5113,7 +7809,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[4] ⚠️ function calls are not analysed yet -0 -> 918 call = (...) => (???*0* | a)( +1307 -> 1317 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1318 call = (...) => (???*0* | a)( ( | null | ???*1* @@ -5179,7 +7879,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* arguments[4] ⚠️ function calls are not analysed yet -0 -> 919 call = (...) => (???*0* | a)( +0 -> 1319 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1320 call = (...) => (???*0* | a)( ( | null | ???*1* @@ -5245,7 +7949,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* arguments[4] ⚠️ function calls are not analysed yet -0 -> 920 call = (...) => (???*0* | a)( +0 -> 1321 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1322 call = (...) => (???*0* | a)( ( | null | ???*1* @@ -5311,7 +8019,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* arguments[4] ⚠️ function calls are not analysed yet -0 -> 924 member call = ???*0*["get"](???*1*) +0 -> 1323 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1327 member call = ???*0*["get"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* ???*2*["pointerId"] @@ -5319,7 +8031,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 925 call = (...) => (???*0* | a)((???*1* | null), ???*3*, ???*4*, ???*5*, ???*6*, ???*7*) +0 -> 1328 call = (...) => (???*0* | a)((???*1* | null), ???*3*, ???*4*, ???*5*, ???*6*, ???*7*) - *0* a ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -5339,7 +8051,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[4] ⚠️ function calls are not analysed yet -0 -> 926 member call = ???*0*["set"]( +0 -> 1329 member call = ???*0*["set"]( ???*1*, ( | ???*3* @@ -5397,7 +8109,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* arguments[3] ⚠️ function calls are not analysed yet -0 -> 930 member call = ???*0*["get"](???*1*) +0 -> 1330 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1334 member call = ???*0*["get"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* ???*2*["pointerId"] @@ -5405,7 +8121,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 931 call = (...) => (???*0* | a)((???*1* | null), ???*3*, ???*4*, ???*5*, ???*6*, ???*7*) +0 -> 1335 call = (...) => (???*0* | a)((???*1* | null), ???*3*, ???*4*, ???*5*, ???*6*, ???*7*) - *0* a ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -5425,7 +8141,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[4] ⚠️ function calls are not analysed yet -0 -> 932 member call = ???*0*["set"]( +0 -> 1336 member call = ???*0*["set"]( ???*1*, ( | ???*3* @@ -5483,29 +8199,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* arguments[3] ⚠️ function calls are not analysed yet -0 -> 934 call = (...) => (b | c | null)(???*0*) +0 -> 1337 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1338 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1340 call = (...) => (b | c | null)(???*0*) - *0* ???*1*["target"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 935 conditional = ???*0* +0 -> 1341 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -935 -> 936 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) +1341 -> 1342 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -935 -> 937 conditional = ???*0* +1341 -> 1343 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -937 -> 939 call = (...) => (b["dehydrated"] | null)(???*0*) +1343 -> 1345 call = (...) => (b["dehydrated"] | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -937 -> 942 call = (???*0* | (...) => (undefined | ???*1*))(???*2*, (...) => undefined) +1343 -> 1348 call = (???*0* | (...) => (undefined | ???*1*))(???*2*, (...) => undefined) - *0* Ic ⚠️ pattern without value - *1* b() @@ -5516,21 +8240,39 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -942 -> 943 call = (???*0* | (...) => undefined)(???*1*) +1348 -> 1349 call = (???*0* | (...) => undefined)(???*1*) - *0* Gc ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -937 -> 948 conditional = ???*0* +1343 -> 1350 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1343 -> 1355 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -948 -> 951 conditional = ???*0* +1355 -> 1358 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 962 call = (...) => ( +1355 -> 1361 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1364 conditional = (null !== ???*0*) +- *0* ???*1*["blockedOn"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +1364 -> 1365 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1364 -> 1372 call = (...) => ( | a | ((3 === b["tag"]) ? b["stateNode"]["containerInfo"] : null) | null @@ -5550,47 +8292,55 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 963 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -963 -> 969 member call = ???*0*["dispatchEvent"](???*1*) +1364 -> 1373 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unknown new expression - ⚠️ This value might have side effects -963 -> 970 call = (...) => (( +1373 -> 1374 call = (...) => (( || !(a) || ((5 !== a["tag"]) && (6 !== a["tag"]) && (13 !== a["tag"]) && (3 !== a["tag"])) ) ? null : a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -963 -> 971 call = (???*0* | (...) => undefined)(???*1*) +1373 -> 1375 call = (???*0* | (...) => undefined)(???*1*) - *0* Fc ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 974 member call = ???*0*["shift"]() +1373 -> 1377 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1373 -> 1379 member call = ???*0*["shift"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 975 call = (...) => (!(1) | ???*0* | !(0))(???*1*) +1373 -> 1385 member call = ???*0*["dispatchEvent"](???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* unknown new expression + ⚠️ This value might have side effects + +0 -> 1386 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1387 call = (...) => (!(1) | ???*0* | !(0))(???*1*) - *0* !(1) ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 977 member call = ???*0*["delete"](???*1*) +0 -> 1389 member call = ???*0*["delete"](???*1*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 978 call = (...) => (!(1) | ???*0* | !(0))( +0 -> 1390 call = (...) => (!(1) | ???*0* | !(0))( ( | null | ???*1* @@ -5641,7 +8391,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[3] ⚠️ function calls are not analysed yet -0 -> 979 call = (...) => (!(1) | ???*0* | !(0))( +0 -> 1391 call = (...) => (!(1) | ???*0* | !(0))( ( | null | ???*1* @@ -5692,7 +8442,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[3] ⚠️ function calls are not analysed yet -0 -> 980 call = (...) => (!(1) | ???*0* | !(0))( +0 -> 1392 call = (...) => (!(1) | ???*0* | !(0))( ( | null | ???*1* @@ -5743,29 +8493,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[3] ⚠️ function calls are not analysed yet -0 -> 982 member call = ???*0*["forEach"]((...) => undefined) +0 -> 1394 member call = ???*0*["forEach"]((...) => undefined) - *0* unknown new expression ⚠️ This value might have side effects -0 -> 984 member call = ???*0*["forEach"]((...) => undefined) +0 -> 1396 member call = ???*0*["forEach"]((...) => undefined) - *0* unknown new expression ⚠️ This value might have side effects -0 -> 989 member call = module["unstable_scheduleCallback"](module["unstable_NormalPriority"], (...) => undefined) - -0 -> 990 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 1401 member call = module["unstable_scheduleCallback"](module["unstable_NormalPriority"], (...) => undefined) -0 -> 993 call = (...) => undefined(???*0*, ???*1*) +0 -> 1404 call = (...) => undefined(???*0*, ???*1*) - *0* [][0] ⚠️ invalid index - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 998 call = (...) => undefined( +0 -> 1409 call = (...) => undefined( ( | null | ???*0* @@ -5816,7 +8560,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[0] ⚠️ function calls are not analysed yet -0 -> 999 call = (...) => undefined( +0 -> 1410 call = (...) => undefined( ( | null | ???*0* @@ -5867,7 +8611,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1000 call = (...) => undefined( +0 -> 1411 call = (...) => undefined( ( | null | ???*0* @@ -5918,23 +8662,33 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1002 member call = ???*0*["forEach"]((...) => ad(b, a)) +0 -> 1413 member call = ???*0*["forEach"]((...) => ad(b, a)) - *0* unknown new expression ⚠️ This value might have side effects -0 -> 1004 member call = ???*0*["forEach"]((...) => ad(b, a)) +0 -> 1415 member call = ???*0*["forEach"]((...) => ad(b, a)) - *0* unknown new expression ⚠️ This value might have side effects -0 -> 1012 call = (...) => (undefined | FreeVar(undefined))((1 | ???*0* | 0 | ???*1*)) +0 -> 1423 call = (...) => (undefined | FreeVar(undefined))((1 | ???*0* | 0 | ???*1*)) - *0* updated with update expression ⚠️ This value might have side effects - *1* [][0] ⚠️ invalid index -0 -> 1015 member call = []["shift"]() +0 -> 1426 member call = []["shift"]() + +0 -> 1427 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 1428 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1019 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +0 -> 1432 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -5944,7 +8698,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -0 -> 1023 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +0 -> 1436 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -5954,13 +8708,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -0 -> 1025 conditional = (true | false | !(???*0*)) +0 -> 1438 conditional = (true | false | !(???*0*)) - *0* !((null | ???*1*)) ⚠️ nested operation - *1* dd ⚠️ circular variable reference -1025 -> 1026 call = (...) => ( +1438 -> 1439 call = (...) => ( | a | ((3 === b["tag"]) ? b["stateNode"]["containerInfo"] : null) | null @@ -5974,11 +8728,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -1025 -> 1027 conditional = ???*0* +1438 -> 1440 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1027 -> 1028 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +1440 -> 1441 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -5990,13 +8744,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[2] ⚠️ function calls are not analysed yet -1027 -> 1029 call = (...) => undefined(???*0*, ???*1*) +1440 -> 1442 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[3] ⚠️ function calls are not analysed yet -1027 -> 1030 call = (...) => (???*0* | !(0) | !(1))(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +1440 -> 1443 call = (...) => (???*0* | !(0) | !(1))(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) - *0* !(0) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -6011,42 +8765,42 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[3] ⚠️ function calls are not analysed yet -1027 -> 1031 conditional = ???*0* +1440 -> 1444 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1031 -> 1033 member call = ???*0*["stopPropagation"]() +1444 -> 1446 member call = ???*0*["stopPropagation"]() - *0* arguments[3] ⚠️ function calls are not analysed yet -1031 -> 1034 call = (...) => undefined(???*0*, ???*1*) +1444 -> 1447 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[3] ⚠️ function calls are not analysed yet -1031 -> 1036 member call = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit"["split"](" ")["indexOf"](???*0*) +1444 -> 1449 member call = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit"["split"](" ")["indexOf"](???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -1031 -> 1037 conditional = ???*0* +1444 -> 1450 conditional = ???*0* - *0* unsupported expression ⚠️ This value might have side effects -1037 -> 1038 call = (...) => (( +1450 -> 1451 call = (...) => (( || !(a) || ((5 !== a["tag"]) && (6 !== a["tag"]) && (13 !== a["tag"]) && (3 !== a["tag"])) ) ? null : a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1037 -> 1039 call = (???*0* | (...) => undefined)(???*1*) +1450 -> 1452 call = (???*0* | (...) => undefined)(???*1*) - *0* Ec ⚠️ pattern without value - *1* max number of linking steps reached ⚠️ This value might have side effects -1037 -> 1040 call = (...) => ( +1450 -> 1453 call = (...) => ( | a | ((3 === b["tag"]) ? b["stateNode"]["containerInfo"] : null) | null @@ -6060,7 +8814,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -1037 -> 1041 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +1450 -> 1454 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -6072,11 +8826,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[2] ⚠️ function calls are not analysed yet -1037 -> 1043 member call = ???*0*["stopPropagation"]() +1450 -> 1456 member call = ???*0*["stopPropagation"]() - *0* arguments[3] ⚠️ function calls are not analysed yet -1037 -> 1044 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, null, ???*3*) +1450 -> 1457 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, null, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -6086,41 +8840,136 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -0 -> 1045 call = (...) => ((3 === a["nodeType"]) ? a["parentNode"] : a)(???*0*) +0 -> 1458 call = (...) => ((3 === a["nodeType"]) ? a["parentNode"] : a)(???*0*) - *0* arguments[3] ⚠️ function calls are not analysed yet -0 -> 1046 call = (...) => (b | c | null)(???*0*) +0 -> 1459 call = (...) => (b | c | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1047 conditional = ???*0* +0 -> 1460 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1047 -> 1048 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) +1460 -> 1461 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1047 -> 1050 call = (...) => (b["dehydrated"] | null)(???*0*) +1460 -> 1463 call = (...) => (b["dehydrated"] | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1047 -> 1051 conditional = ???*0* +1460 -> 1464 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1051 -> 1056 conditional = ???*0* +1464 -> 1465 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1460 -> 1466 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1056 -> 1058 conditional = ???*0* +1466 -> 1471 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1061 call = module["unstable_getCurrentPriorityLevel"]() +1471 -> 1473 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 1071 member call = (???*0* ? (null["value"] | ???*1* | ???*16*) : (null["textContent"] | ???*18* | ???*33*))["slice"]((???*35* | 0 | ???*36*), (???*37* ? ???*38* : ???*39*)) +1471 -> 1476 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1477 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1478 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1479 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1480 call = module["unstable_getCurrentPriorityLevel"]() + +0 -> 1481 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1482 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1483 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1484 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1485 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1486 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1487 conditional = (null | ???*0* | ???*18*) +- *0* ???*1*((???*12* | 0 | ???*13*), ???*14*) + ⚠️ unknown callee + ⚠️ This value might have side effects +- *1* ???*2*["slice"] + ⚠️ unknown object +- *2* (???*3* ? (null["value"] | ???*4* | ???*6*) : (null["textContent"] | ???*8* | ???*10*)) + ⚠️ nested operation +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* ???*5*["value"] + ⚠️ unknown object +- *5* (??? ? (??? | ???) : (??? | ??? | ???)) + ⚠️ nested operation +- *6* ???*7*["value"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *7* unknown new expression + ⚠️ This value might have side effects +- *8* ???*9*["textContent"] + ⚠️ unknown object +- *9* (??? ? (??? | ???) : (??? | ??? | ???)) + ⚠️ nested operation +- *10* ???*11*["textContent"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *11* unknown new expression + ⚠️ This value might have side effects +- *12* a + ⚠️ pattern without value +- *13* updated with update expression + ⚠️ This value might have side effects +- *14* (???*15* ? ???*16* : ???*17*) + ⚠️ nested operation +- *15* unsupported expression + ⚠️ This value might have side effects +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* unsupported expression + ⚠️ This value might have side effects +- *18* unsupported expression + ⚠️ This value might have side effects + +1487 -> 1488 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1487 -> 1498 member call = (???*0* ? (null["value"] | ???*1* | ???*16*) : (null["textContent"] | ???*18* | ???*33*))["slice"]((???*35* | 0 | ???*36*), (???*37* ? ???*38* : ???*39*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["value"] @@ -6214,7 +9063,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *39* unsupported expression ⚠️ This value might have side effects -0 -> 1074 conditional = (???*0* | (13 === (???*1* | ???*2* | 13))) +1487 -> 1499 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1502 conditional = (???*0* | (13 === (???*1* | ???*2* | 13))) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] @@ -6224,55 +9077,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* a ⚠️ circular variable reference -0 -> 1082 member call = ???*0*["hasOwnProperty"](???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* c - ⚠️ pattern without value - -0 -> 1085 conditional = (???*0* | ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*[c] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -1085 -> 1086 call = (???*0* | ???*1*)(???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*[c] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[3] - ⚠️ function calls are not analysed yet +0 -> 1503 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1090 conditional = (null != ???*0*) -- *0* ???*1*["defaultPrevented"] - ⚠️ unknown object -- *1* arguments[3] - ⚠️ function calls are not analysed yet +0 -> 1504 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1093 conditional = (???*0* ? ???*3* : ???*5*) -- *0* (null != ???*1*) - ⚠️ nested operation -- *1* ???*2*["defaultPrevented"] - ⚠️ unknown object -- *2* arguments[3] - ⚠️ function calls are not analysed yet -- *3* ???*4*["defaultPrevented"] - ⚠️ unknown object -- *4* arguments[3] - ⚠️ function calls are not analysed yet -- *5* (false === ???*6*) - ⚠️ nested operation -- *6* ???*7*["returnValue"] - ⚠️ unknown object -- *7* arguments[3] - ⚠️ function calls are not analysed yet +0 -> 1505 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1099 conditional = ???*0* +0 -> 1510 conditional = ???*0* - *0* ???*1*["preventDefault"] ⚠️ unknown object ⚠️ This value might have side effects @@ -6282,14 +9099,14 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -1099 -> 1101 member call = ???*0*["preventDefault"]() +1510 -> 1512 member call = ???*0*["preventDefault"]() - *0* ???*1*["nativeEvent"] ⚠️ unknown object ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -0 -> 1107 conditional = ???*0* +0 -> 1518 conditional = ???*0* - *0* ???*1*["stopPropagation"] ⚠️ unknown object ⚠️ This value might have side effects @@ -6299,14 +9116,14 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -1107 -> 1109 member call = ???*0*["stopPropagation"]() +1518 -> 1520 member call = ???*0*["stopPropagation"]() - *0* ???*1*["nativeEvent"] ⚠️ unknown object ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -0 -> 1113 call = ???*0*( +0 -> 1524 call = ???*0*( (...) => ???*2*["prototype"], { "preventDefault": (...) => undefined, @@ -6324,14 +9141,74 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 1116 free var = FreeVar(Date) +0 -> 1525 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1533 member call = ???*0*["hasOwnProperty"](???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* c + ⚠️ pattern without value + +0 -> 1536 conditional = (???*0* | ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*[c] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +1536 -> 1537 call = (???*0* | ???*1*)(???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*[c] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* arguments[3] + ⚠️ function calls are not analysed yet + +0 -> 1541 conditional = (null != ???*0*) +- *0* ???*1*["defaultPrevented"] + ⚠️ unknown object +- *1* arguments[3] + ⚠️ function calls are not analysed yet + +0 -> 1544 conditional = (???*0* ? ???*3* : ???*5*) +- *0* (null != ???*1*) + ⚠️ nested operation +- *1* ???*2*["defaultPrevented"] + ⚠️ unknown object +- *2* arguments[3] + ⚠️ function calls are not analysed yet +- *3* ???*4*["defaultPrevented"] + ⚠️ unknown object +- *4* arguments[3] + ⚠️ function calls are not analysed yet +- *5* (false === ???*6*) + ⚠️ nested operation +- *6* ???*7*["returnValue"] + ⚠️ unknown object +- *7* arguments[3] + ⚠️ function calls are not analysed yet + +0 -> 1546 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1549 free var = FreeVar(Date) -0 -> 1117 member call = ???*0*["now"]() +0 -> 1550 member call = ???*0*["now"]() - *0* FreeVar(Date) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1118 call = (...) => b( +0 -> 1551 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1552 call = (...) => b( { "eventPhase": 0, "bubbles": 0, @@ -6342,7 +9219,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` } ) -0 -> 1119 call = ???*0*( +0 -> 1553 call = ???*0*( {}, { "eventPhase": 0, @@ -6361,7 +9238,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1120 call = (...) => b(???*0*) +0 -> 1554 call = (...) => b(???*0*) - *0* ???*1*({}, sd, {"view": 0, "detail": 0}) ⚠️ unknown callee ⚠️ This value might have side effects @@ -6372,7 +9249,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1122 conditional = (???*0* === ???*1*) +0 -> 1556 conditional = (???*0* === ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["relatedTarget"] @@ -6380,7 +9257,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -1122 -> 1125 conditional = (???*0* === ???*2*) +1556 -> 1559 conditional = (???*0* === ???*2*) - *0* ???*1*["fromElement"] ⚠️ unknown object - *1* arguments[0] @@ -6390,7 +9267,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1131 conditional = (???*0* | ???*1* | ("mousemove" === ???*2*)) +0 -> 1563 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1565 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1567 conditional = (???*0* | ???*1* | ("mousemove" === ???*2*)) - *0* yd ⚠️ pattern without value - *1* arguments[0] @@ -6400,7 +9285,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1137 call = ???*0*( +0 -> 1572 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1574 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1575 call = ???*0*( {}, ???*2*, { @@ -6442,7 +9335,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* unsupported expression ⚠️ This value might have side effects -0 -> 1138 call = (...) => b(???*0*) +0 -> 1576 call = (...) => b(???*0*) - *0* ???*1*( {}, ud, @@ -6474,7 +9367,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1139 call = ???*0*({}, ???*2*, {"dataTransfer": 0}) +0 -> 1577 call = ???*0*({}, ???*2*, {"dataTransfer": 0}) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -6512,7 +9405,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1140 call = (...) => b(???*0*) +0 -> 1578 call = (...) => b(???*0*) - *0* ???*1*({}, Ad, {"dataTransfer": 0}) ⚠️ unknown callee ⚠️ This value might have side effects @@ -6523,7 +9416,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1141 call = ???*0*({}, ???*2*, {"relatedTarget": 0}) +0 -> 1579 call = ???*0*({}, ???*2*, {"relatedTarget": 0}) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -6540,7 +9433,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1142 call = (...) => b(???*0*) +0 -> 1580 call = (...) => b(???*0*) - *0* ???*1*({}, ud, {"relatedTarget": 0}) ⚠️ unknown callee ⚠️ This value might have side effects @@ -6551,7 +9444,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1143 call = ???*0*( +0 -> 1581 call = ???*0*( {}, { "eventPhase": 0, @@ -6570,7 +9463,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1144 call = (...) => b(???*0*) +0 -> 1582 call = (...) => b(???*0*) - *0* ???*1*( {}, sd, @@ -6585,9 +9478,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1147 free var = FreeVar(window) +0 -> 1585 free var = FreeVar(window) + +0 -> 1586 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1148 call = ???*0*( +0 -> 1587 call = ???*0*( {}, { "eventPhase": 0, @@ -6610,7 +9507,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 1149 call = (...) => b(???*0*) +0 -> 1588 call = (...) => b(???*0*) - *0* ???*1*({}, sd, {"clipboardData": *anonymous function 28936*}) ⚠️ unknown callee ⚠️ This value might have side effects @@ -6621,7 +9518,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1150 call = ???*0*( +0 -> 1589 call = ???*0*( {}, { "eventPhase": 0, @@ -6640,7 +9537,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1151 call = (...) => b(???*0*) +0 -> 1590 call = (...) => b(???*0*) - *0* ???*1*({}, sd, {"data": 0}) ⚠️ unknown callee ⚠️ This value might have side effects @@ -6651,7 +9548,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1154 conditional = ???*0* +0 -> 1593 conditional = ???*0* - *0* ???*1*["getModifierState"] ⚠️ unknown object ⚠️ This value might have side effects @@ -6661,7 +9558,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -1154 -> 1156 member call = ???*0*["getModifierState"]( +1593 -> 1595 member call = ???*0*["getModifierState"]( (???*2* | "altKey" | "ctrlKey" | "metaKey" | "shiftKey" | ???*3*) ) - *0* ???*1*["nativeEvent"] @@ -6677,7 +9574,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* a ⚠️ circular variable reference -0 -> 1160 conditional = ( +0 -> 1598 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1599 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1601 conditional = ( | ???*0* | ((???*2* | ???*3*) ? (???*7* | ???*8* | 13) : 0)["key"] ) @@ -6702,13 +9607,44 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* a ⚠️ circular variable reference -0 -> 1165 conditional = ("keypress" === ???*0*) +1601 -> 1605 conditional = ("Unidentified" !== ( + | "Escape" + | " " + | "ArrowLeft" + | "ArrowUp" + | "ArrowRight" + | "ArrowDown" + | "Delete" + | "OS" + | "ContextMenu" + | "ScrollLock" + | "Unidentified" + | ???*0* + | ???*3* +)) +- *0* {}[???*1*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *1* ???*2*["key"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["key"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet + +1605 -> 1606 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1608 conditional = ("keypress" === ???*0*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -1165 -> 1166 call = (...) => ((???*0* || (13 === a)) ? a : 0)( +1608 -> 1609 call = (...) => ((???*0* || (13 === a)) ? a : 0)( (???*1* | ((???*2* | ???*3*) ? (???*7* | ???*8* | 13) : 0)) ) - *0* unsupported expression @@ -6732,7 +9668,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* a ⚠️ circular variable reference -1165 -> 1167 conditional = (13 === (???*0* | ???*1*)) +1608 -> 1610 conditional = (13 === (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ((???*2* | ???*3*) ? (???*7* | ???*8* | 13) : 0) @@ -6754,9 +9690,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* a ⚠️ circular variable reference -1167 -> 1169 free var = FreeVar(String) +1610 -> 1612 free var = FreeVar(String) -1167 -> 1170 member call = ???*0*["fromCharCode"]( +1610 -> 1613 member call = ???*0*["fromCharCode"]( (???*1* | ((???*2* | ???*3*) ? (???*7* | ???*8* | 13) : 0)) ) - *0* FreeVar(String) @@ -6781,7 +9717,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* a ⚠️ circular variable reference -1165 -> 1173 conditional = (("keydown" === ???*0*) | ("keyup" === ???*2*)) +1608 -> 1616 conditional = (("keydown" === ???*0*) | ("keyup" === ???*2*)) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] @@ -6791,19 +9727,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1177 conditional = ("keypress" === ???*0*) +0 -> 1619 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1621 conditional = ("keypress" === ???*0*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -1177 -> 1178 call = (...) => ((???*0* || (13 === a)) ? a : 0)(???*1*) +1621 -> 1622 call = (...) => ((???*0* || (13 === a)) ? a : 0)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1181 conditional = (("keydown" === ???*0*) | ("keyup" === ???*2*)) +0 -> 1623 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1626 conditional = (("keydown" === ???*0*) | ("keyup" === ???*2*)) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] @@ -6813,19 +9757,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1184 conditional = ("keypress" === ???*0*) +0 -> 1628 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1630 conditional = ("keypress" === ???*0*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -1184 -> 1185 call = (...) => ((???*0* || (13 === a)) ? a : 0)(???*1*) +1630 -> 1631 call = (...) => ((???*0* || (13 === a)) ? a : 0)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -1184 -> 1188 conditional = (("keydown" === ???*0*) | ("keyup" === ???*2*)) +1630 -> 1634 conditional = (("keydown" === ???*0*) | ("keyup" === ???*2*)) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] @@ -6835,7 +9783,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1190 call = ???*0*( +0 -> 1636 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1637 call = ???*0*( {}, ???*2*, { @@ -6876,7 +9828,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -0 -> 1191 call = (...) => b(???*0*) +0 -> 1638 call = (...) => b(???*0*) - *0* ???*1*( {}, ud, @@ -6905,7 +9857,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1192 call = ???*0*( +0 -> 1639 call = ???*0*( {}, ???*2*, { @@ -6958,7 +9910,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1193 call = (...) => b(???*0*) +0 -> 1640 call = (...) => b(???*0*) - *0* ???*1*( {}, Ad, @@ -6984,7 +9936,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1194 call = ???*0*( +0 -> 1641 call = ???*0*( {}, ???*2*, { @@ -7014,7 +9966,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1195 call = (...) => b(???*0*) +0 -> 1642 call = (...) => b(???*0*) - *0* ???*1*( {}, ud, @@ -7038,7 +9990,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1196 call = ???*0*( +0 -> 1643 call = ???*0*( {}, { "eventPhase": 0, @@ -7057,7 +10009,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1197 call = (...) => b(???*0*) +0 -> 1644 call = (...) => b(???*0*) - *0* ???*1*( {}, sd, @@ -7072,7 +10024,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1203 call = ???*0*( +0 -> 1647 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1651 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1652 call = ???*0*( {}, ???*2*, { @@ -7135,7 +10095,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* unsupported expression ⚠️ This value might have side effects -0 -> 1204 call = (...) => b(???*0*) +0 -> 1653 call = (...) => b(???*0*) - *0* ???*1*( {}, Ad, @@ -7155,28 +10115,44 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1205 free var = FreeVar(window) +0 -> 1654 free var = FreeVar(window) -0 -> 1206 free var = FreeVar(document) +0 -> 1655 free var = FreeVar(document) -0 -> 1208 free var = FreeVar(document) +0 -> 1657 free var = FreeVar(document) -0 -> 1209 free var = FreeVar(window) +0 -> 1658 free var = FreeVar(window) -0 -> 1211 free var = FreeVar(String) +0 -> 1660 free var = FreeVar(String) -0 -> 1212 member call = ???*0*["fromCharCode"](32) +0 -> 1661 member call = ???*0*["fromCharCode"](32) - *0* FreeVar(String) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1215 member call = [9, 13, 27, 32]["indexOf"](???*0*) +0 -> 1664 member call = [9, 13, 27, 32]["indexOf"](???*0*) - *0* ???*1*["keyCode"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1218 conditional = (("object" === ???*0*) | ???*4*) +0 -> 1665 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1667 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1668 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1669 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1671 conditional = (("object" === ???*0*) | ???*4*) - *0* typeof((???*1* | ???*2*)) ⚠️ nested operation - *1* arguments[0] @@ -7188,13 +10164,35 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -0 -> 1220 call = (...) => ((("object" === typeof(a)) && ???*0*) ? a["data"] : null)(???*1*) +0 -> 1673 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1674 call = (...) => ((("object" === typeof(a)) && ???*0*) ? a["data"] : null)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1223 conditional = (((???*0* | ???*1*) === ???*3*) | false | true) +0 -> 1675 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1677 conditional = (32 !== ???*0*) +- *0* ???*1*["which"] + ⚠️ unknown object +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +1677 -> 1678 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1677 -> 1679 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1681 conditional = (((???*0* | ???*1*) === ???*3*) | false | true) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["data"] @@ -7208,9 +10206,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1224 conditional = (false | true) +0 -> 1682 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -1224 -> 1225 call = (...) => (undefined | (???*0* !== $d["indexOf"](b["keyCode"])) | (229 !== b["keyCode"]) | !(0) | !(1))((???*1* | null | ???*2* | ???*20*), ???*21*) +0 -> 1683 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1684 conditional = (false | true) + +1684 -> 1685 call = (...) => (undefined | (???*0* !== $d["indexOf"](b["keyCode"])) | (229 !== b["keyCode"]) | !(0) | !(1))((???*1* | null | ???*2* | ???*20*), ???*21*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] @@ -7259,15 +10265,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* arguments[1] ⚠️ function calls are not analysed yet -1224 -> 1226 conditional = ???*0* +1684 -> 1686 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1226 -> 1227 call = (...) => (md | ???*0*)() +1686 -> 1687 call = (...) => (md | ???*0*)() - *0* unsupported expression ⚠️ This value might have side effects -0 -> 1233 conditional = (!(???*0*) | ???*2*) +1684 -> 1688 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1684 -> 1689 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1684 -> 1695 conditional = (!(???*0*) | ???*2*) - *0* ???*1*["ctrlKey"] ⚠️ unknown object - *1* arguments[1] @@ -7277,7 +10291,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -1233 -> 1237 conditional = (???*0* | ???*2*) +1695 -> 1699 conditional = (???*0* | ???*2*) - *0* ???*1*["char"] ⚠️ unknown object - *1* arguments[1] @@ -7285,15 +10299,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -1233 -> 1240 conditional = ???*0* +1699 -> 1701 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1699 -> 1703 conditional = ???*0* - *0* ???*1*["which"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -1240 -> 1242 free var = FreeVar(String) +1703 -> 1705 free var = FreeVar(String) -1240 -> 1244 member call = ???*0*["fromCharCode"](???*1*) +1703 -> 1707 member call = ???*0*["fromCharCode"](???*1*) - *0* FreeVar(String) ⚠️ unknown global ⚠️ This value might have side effects @@ -7302,7 +10320,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1246 conditional = (!(???*0*) | !((???*3* | ???*7*)) | null | ???*8* | ???*10* | ("ko" !== ???*11*)) +1703 -> 1708 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1684 -> 1709 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1684 -> 1711 conditional = (!(???*0*) | !((???*3* | ???*7*)) | null | ???*8* | ???*10* | ("ko" !== ???*11*)) - *0* ("undefined" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -7334,13 +10360,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1251 member call = ???*0*["toLowerCase"]() +1684 -> 1713 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1684 -> 1714 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1718 member call = ???*0*["toLowerCase"]() - *0* ???*1*["nodeName"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1252 conditional = ("input" === (???*0* | ???*1* | ???*3*)) +0 -> 1719 conditional = ("input" === (???*0* | ???*1* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["nodeName"] @@ -7356,7 +10390,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -1252 -> 1255 conditional = ("textarea" === (???*0* | ???*1* | ???*3*)) +1719 -> 1722 conditional = ("textarea" === (???*0* | ???*1* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["nodeName"] @@ -7372,15 +10406,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1256 call = (...) => undefined(???*0*) +0 -> 1723 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1724 call = (...) => undefined(???*0*) - *0* arguments[3] ⚠️ function calls are not analysed yet -0 -> 1257 call = (...) => d((???*0* | []), "onChange") +0 -> 1725 call = (...) => d((???*0* | []), "onChange") - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1260 member call = ???*0*["push"]( +0 -> 1728 member call = ???*0*["push"]( {"event": (???*1* | ???*2*), "listeners": (???*3* | [])} ) - *0* arguments[0] @@ -7392,21 +10430,63 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1261 call = (...) => undefined(???*0*, 0) +0 -> 1729 call = (...) => undefined(???*0*, 0) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1262 call = (...) => (undefined | a["stateNode"])(???*0*) +0 -> 1730 call = (...) => (undefined | a["stateNode"])(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1263 call = (...) => (!(1) | !(0) | ((a !== c) ? !(0) : !(1)))((undefined | ???*0*)) +0 -> 1731 call = (...) => (!(1) | !(0) | ((a !== c) ? !(0) : !(1)))((undefined | ???*0*)) - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1264 conditional = !(???*0*) +0 -> 1732 conditional = (false | true | (???*0* ? true : false)) +- *0* ((undefined | ???*1* | "" | ???*3*) !== ???*13*) + ⚠️ nested operation +- *1* ???*2*["stateNode"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ((???*4* | ???*5*) ? ???*8* : ???*11*) + ⚠️ nested operation +- *4* unsupported expression + ⚠️ This value might have side effects +- *5* ("input" === ???*6*) + ⚠️ nested operation +- *6* ???*7*() + ⚠️ nested operation +- *7* ???["toLowerCase"] + ⚠️ unknown object +- *8* (???*9* ? "true" : "false") + ⚠️ nested operation +- *9* ???*10*["checked"] + ⚠️ unknown object +- *10* a + ⚠️ circular variable reference +- *11* ???*12*["value"] + ⚠️ unknown object +- *12* a + ⚠️ circular variable reference +- *13* undefined["_valueTracker"]["getValue"]() + ⚠️ nested operation + +1732 -> 1733 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1734 conditional = ("change" === ???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +1734 -> 1735 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1736 conditional = !(???*0*) - *0* ("undefined" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -7415,7 +10495,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1264 -> 1265 conditional = !(???*0*) +1736 -> 1737 conditional = !(???*0*) - *0* ("undefined" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -7424,9 +10504,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1265 -> 1266 free var = FreeVar(document) +1737 -> 1738 free var = FreeVar(document) -1265 -> 1267 conditional = !((???*0* | ???*1*)) +1737 -> 1739 conditional = !((???*0* | ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* ("function" === ???*2*) @@ -7443,14 +10523,14 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1267 -> 1269 free var = FreeVar(document) +1739 -> 1741 free var = FreeVar(document) -1267 -> 1270 member call = ???*0*["createElement"]("div") +1739 -> 1742 member call = ???*0*["createElement"]("div") - *0* FreeVar(document) ⚠️ unknown global ⚠️ This value might have side effects -1267 -> 1272 member call = ???*0*["setAttribute"]("oninput", "return;") +1739 -> 1744 member call = ???*0*["setAttribute"]("oninput", "return;") - *0* ???*1*["createElement"]("div") ⚠️ unknown callee object ⚠️ This value might have side effects @@ -7458,21 +10538,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1264 -> 1275 free var = FreeVar(document) +1736 -> 1747 free var = FreeVar(document) -1264 -> 1277 free var = FreeVar(document) +1736 -> 1749 free var = FreeVar(document) -0 -> 1279 member call = (null | ???*0*)["detachEvent"]("onpropertychange", (...) => undefined) +0 -> 1751 member call = (null | ???*0*)["detachEvent"]("onpropertychange", (...) => undefined) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1281 call = (...) => (undefined | a)((null | ???*0* | ???*1*)) +0 -> 1753 call = (...) => (undefined | a)((null | ???*0* | ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 1282 conditional = (("value" === ???*0*) | undefined | null | ???*2* | ???*3*) +0 -> 1754 conditional = (("value" === ???*0*) | undefined | null | ???*2* | ???*3*) - *0* ???*1*["propertyName"] ⚠️ unknown object - *1* arguments[0] @@ -7482,11 +10562,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -1282 -> 1283 call = (...) => ((3 === a["nodeType"]) ? a["parentNode"] : a)(???*0*) +1754 -> 1755 call = (...) => ((3 === a["nodeType"]) ? a["parentNode"] : a)(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -1282 -> 1284 call = (...) => undefined( +1754 -> 1756 call = (...) => undefined( [], (null | ???*0* | ???*1*), ???*2*, @@ -7530,21 +10610,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1282 -> 1285 call = (...) => (undefined | a(b, c) | Gb(a, b, c))((...) => undefined, []) +1754 -> 1757 call = (...) => (undefined | a(b, c) | Gb(a, b, c))((...) => undefined, []) -0 -> 1286 conditional = ("focusin" === ???*0*) +0 -> 1758 conditional = ("focusin" === ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -1286 -> 1287 call = (...) => undefined() +1758 -> 1759 call = (...) => undefined() -1286 -> 1289 member call = (null | ???*0*)["attachEvent"]("onpropertychange", (...) => undefined) +1758 -> 1761 member call = (null | ???*0*)["attachEvent"]("onpropertychange", (...) => undefined) - *0* arguments[1] ⚠️ function calls are not analysed yet -1286 -> 1290 call = (...) => undefined() +1758 -> 1762 call = (...) => undefined() -0 -> 1291 conditional = (("selectionchange" === ???*0*) | ("keyup" === ???*1*) | ("keydown" === ???*2*)) +0 -> 1763 conditional = (("selectionchange" === ???*0*) | ("keyup" === ???*1*) | ("keydown" === ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] @@ -7552,33 +10632,49 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -1291 -> 1292 call = (...) => (undefined | a)((null | ???*0* | ???*1*)) +1763 -> 1764 call = (...) => (undefined | a)((null | ???*0* | ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 1293 conditional = ("click" === ???*0*) +1763 -> 1765 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1766 conditional = ("click" === ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -1293 -> 1294 call = (...) => (undefined | a)(???*0*) +1766 -> 1767 call = (...) => (undefined | a)(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1295 conditional = (("input" === ???*0*) | ("change" === ???*1*)) +1766 -> 1768 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1769 conditional = (("input" === ???*0*) | ("change" === ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -1295 -> 1296 call = (...) => (undefined | a)(???*0*) +1769 -> 1770 call = (...) => (undefined | a)(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1298 free var = FreeVar(Object) +1769 -> 1771 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1299 conditional = ("function" === ???*0*) +0 -> 1772 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1774 free var = FreeVar(Object) + +0 -> 1775 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* ???*2*["is"] @@ -7588,9 +10684,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1299 -> 1301 free var = FreeVar(Object) +1775 -> 1777 free var = FreeVar(Object) -0 -> 1302 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) +0 -> 1778 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -7618,25 +10714,94 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1304 free var = FreeVar(Object) +0 -> 1779 conditional = ???*0* +- *0* ???*1*(???*10*, ???*11*) + ⚠️ unknown callee +- *1* (???*2* ? ???*5* : (...) => ???*7*) + ⚠️ nested operation +- *2* ("function" === ???*3*) + ⚠️ nested operation +- *3* typeof(???*4*) + ⚠️ nested operation +- *4* ???["is"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *5* ???*6*["is"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *7* (((a === b) && ((0 !== a) || (???*8* === ???*9*))) || ((a !== a) && (b !== b))) + ⚠️ nested operation +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* arguments[0] + ⚠️ function calls are not analysed yet +- *11* arguments[1] + ⚠️ function calls are not analysed yet + +1779 -> 1780 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1305 member call = ???*0*["keys"](???*1*) +1779 -> 1781 conditional = (("object" !== ???*0*) | (null === ???*2*)) +- *0* typeof(???*1*) + ⚠️ nested operation +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +1781 -> 1782 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1781 -> 1784 free var = FreeVar(Object) + +1781 -> 1785 member call = ???*0*["keys"](???*1*) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1307 free var = FreeVar(Object) +1781 -> 1787 free var = FreeVar(Object) -0 -> 1308 member call = ???*0*["keys"](???*1*) +1781 -> 1788 member call = ???*0*["keys"](???*1*) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1314 member call = ???*0*["call"](???*3*, ???*4*) +1781 -> 1791 conditional = (???*0* !== (???*3* | 0["length"])) +- *0* ???*1*["length"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *1* ???*2*["keys"](a) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *2* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* ???*4*["length"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *4* ???*5*["keys"](b) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *5* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects + +1791 -> 1792 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1791 -> 1796 member call = ???*0*["call"](???*3*, ???*4*) - *0* ???*1*["hasOwnProperty"] ⚠️ unknown object ⚠️ This value might have side effects @@ -7658,7 +10823,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1317 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*11*) +1791 -> 1799 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*11*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -7690,7 +10855,67 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1320 call = (...) => a( +1791 -> 1800 conditional = (!(???*0*) | !(???*4*)) +- *0* ???*1*["call"](b, e) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *1* ???*2*["hasOwnProperty"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *2* ???*3*["prototype"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *3* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* ???*5*(???*14*, ???*16*) + ⚠️ unknown callee +- *5* (???*6* ? ???*9* : (...) => ???*11*) + ⚠️ nested operation +- *6* ("function" === ???*7*) + ⚠️ nested operation +- *7* typeof(???*8*) + ⚠️ nested operation +- *8* ???["is"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *9* ???*10*["is"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *10* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *11* ( + || ((a === b) && ((0 !== a) || (???*12* === ???*13*))) + || ((a !== a) && (b !== b)) + ) + ⚠️ nested operation +- *12* unsupported expression + ⚠️ This value might have side effects +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* ???*15*[e] + ⚠️ unknown object +- *15* arguments[0] + ⚠️ function calls are not analysed yet +- *16* ???*17*[e] + ⚠️ unknown object +- *17* arguments[1] + ⚠️ function calls are not analysed yet + +1800 -> 1801 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1802 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1805 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1806 call = (...) => a( (???*0* | 0 | ???*1* | (???*2* + (???*3* | ???*6*))) ) - *0* arguments[0] @@ -7714,7 +10939,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unsupported expression ⚠️ This value might have side effects -0 -> 1322 conditional = (3 === (???*0* | 0["nodeType"] | ???*2*)) +0 -> 1808 conditional = (3 === (???*0* | 0["nodeType"] | ???*2*)) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[0] @@ -7725,7 +10950,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -0 -> 1326 conditional = (???*0* | 0["nextSibling"] | (???*2* + ???*3*)["nextSibling"] | ???*6*) +1808 -> 1811 conditional = ???*0* +- *0* unsupported expression + ⚠️ This value might have side effects + +1811 -> 1812 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1814 conditional = (???*0* | 0["nextSibling"] | (???*2* + ???*3*)["nextSibling"] | ???*6*) - *0* ???*1*["nextSibling"] ⚠️ unknown object - *1* arguments[0] @@ -7744,7 +10977,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported expression ⚠️ This value might have side effects -0 -> 1329 call = (...) => a( +0 -> 1817 call = (...) => a( (???*0* | 0 | ???*1* | (???*2* + ???*3*) | ???*6* | ???*8* | ???*9*) ) - *0* arguments[0] @@ -7768,17 +11001,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* c ⚠️ circular variable reference -0 -> 1330 conditional = ???*0* +0 -> 1818 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analysed yet -1330 -> 1331 conditional = (???*0* === ???*1*) +1818 -> 1819 conditional = (???*0* === ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -1331 -> 1333 conditional = (???*0* | (3 === ???*1*)) +1819 -> 1821 conditional = (???*0* | (3 === ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["nodeType"] @@ -7786,7 +11019,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -1333 -> 1335 conditional = (???*0* | (3 === ???*1*)) +1821 -> 1823 conditional = (???*0* | (3 === ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["nodeType"] @@ -7794,7 +11027,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -1335 -> 1337 call = (...) => ((a && b) ? ((a === b) ? !(0) : ((a && (3 === a["nodeType"])) ? !(1) : ((b && (3 === b["nodeType"])) ? Le(a, b["parentNode"]) : (???*0* ? a["contains"](b) : (a["compareDocumentPosition"] ? !(!(???*1*)) : !(1)))))) : !(1))(???*2*, ???*3*) +1823 -> 1825 call = (...) => ((a && b) ? ((a === b) ? !(0) : ((a && (3 === a["nodeType"])) ? !(1) : ((b && (3 === b["nodeType"])) ? Le(a, b["parentNode"]) : (???*0* ? a["contains"](b) : (a["compareDocumentPosition"] ? !(!(???*1*)) : !(1)))))) : !(1))(???*2*, ???*3*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -7806,33 +11039,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -1335 -> 1339 member call = ???*0*["contains"](???*1*) +1823 -> 1827 member call = ???*0*["contains"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -1335 -> 1341 conditional = ???*0* +1823 -> 1829 conditional = ???*0* - *0* ???*1*["compareDocumentPosition"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -1341 -> 1343 member call = ???*0*["compareDocumentPosition"](???*1*) +1829 -> 1831 member call = ???*0*["compareDocumentPosition"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1344 free var = FreeVar(window) +0 -> 1832 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1833 free var = FreeVar(window) -0 -> 1345 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])() +0 -> 1834 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])() -0 -> 1350 conditional = ???*0* +0 -> 1839 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1353 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])( +0 -> 1842 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])( ( | ???*0* | undefined["contentWindow"]["document"] @@ -7932,15 +11169,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *35* unsupported expression ⚠️ This value might have side effects -0 -> 1357 member call = ???*0*["toLowerCase"]() +0 -> 1843 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1847 member call = ???*0*["toLowerCase"]() - *0* ???*1*["nodeName"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1364 call = (...) => b() +0 -> 1854 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1855 call = (...) => b() -0 -> 1370 call = (...) => ((a && b) ? ((a === b) ? !(0) : ((a && (3 === a["nodeType"])) ? !(1) : ((b && (3 === b["nodeType"])) ? Le(a, b["parentNode"]) : (???*0* ? a["contains"](b) : (a["compareDocumentPosition"] ? !(!(???*1*)) : !(1)))))) : !(1))(???*2*, ???*3*) +0 -> 1861 call = (...) => ((a && b) ? ((a === b) ? !(0) : ((a && (3 === a["nodeType"])) ? !(1) : ((b && (3 === b["nodeType"])) ? Le(a, b["parentNode"]) : (???*0* ? a["contains"](b) : (a["compareDocumentPosition"] ? !(!(???*1*)) : !(1)))))) : !(1))(???*2*, ???*3*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -7950,11 +11195,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1371 conditional = ???*0* +0 -> 1862 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1371 -> 1372 call = (...) => ( +1862 -> 1863 call = (...) => ( && b && ( || ( @@ -7974,13 +11219,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *0* max number of linking steps reached ⚠️ This value might have side effects -1371 -> 1373 conditional = ???*0* +1862 -> 1864 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1379 free var = FreeVar(Math) +1864 -> 1870 free var = FreeVar(Math) -1373 -> 1382 member call = ???*0*["min"](???*1*, ???*2*) +1864 -> 1873 member call = ???*0*["min"](???*1*, ???*2*) - *0* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects @@ -7989,17 +11234,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1384 free var = FreeVar(document) +1864 -> 1875 free var = FreeVar(document) -1373 -> 1386 free var = FreeVar(window) +1864 -> 1877 free var = FreeVar(window) -1373 -> 1389 member call = ???*0*["getSelection"]() +1864 -> 1880 member call = ???*0*["getSelection"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1393 free var = FreeVar(Math) +1864 -> 1884 free var = FreeVar(Math) -1373 -> 1395 member call = ???*0*["min"](???*1*, ???*2*) +1864 -> 1886 member call = ???*0*["min"](???*1*, ???*2*) - *0* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects @@ -8008,13 +11253,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1397 conditional = ???*0* +1864 -> 1888 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1397 -> 1399 free var = FreeVar(Math) +1888 -> 1890 free var = FreeVar(Math) -1397 -> 1401 member call = ???*0*["min"](???*1*, ???*2*) +1888 -> 1892 member call = ???*0*["min"](???*1*, ???*2*) - *0* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects @@ -8023,7 +11268,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1403 call = (...) => (undefined | {"node": c, "offset": ???*0*})(???*1*, ???*2*) +1864 -> 1894 call = (...) => (undefined | {"node": c, "offset": ???*0*})(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -8031,7 +11276,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1404 call = (...) => (undefined | {"node": c, "offset": ???*0*})(???*1*, ???*2*) +1864 -> 1895 call = (...) => (undefined | {"node": c, "offset": ???*0*})(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -8039,11 +11284,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1415 member call = ???*0*["createRange"]() +1864 -> 1906 member call = ???*0*["createRange"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1419 member call = ???*0*["setStart"](???*1*, ???*2*) +1864 -> 1910 member call = ???*0*["setStart"](???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -8051,17 +11296,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1421 member call = ???*0*["removeAllRanges"]() +1864 -> 1912 member call = ???*0*["removeAllRanges"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1423 member call = ???*0*["addRange"](???*1*) +1864 -> 1914 member call = ???*0*["addRange"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1427 member call = ???*0*["extend"](???*1*, ???*2*) +1864 -> 1918 member call = ???*0*["extend"](???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -8069,7 +11314,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1431 member call = ???*0*["setEnd"](???*1*, ???*2*) +1864 -> 1922 member call = ???*0*["setEnd"](???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -8077,27 +11322,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1373 -> 1433 member call = ???*0*["addRange"](???*1*) +1864 -> 1924 member call = ???*0*["addRange"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1371 -> 1439 member call = ???*0*["push"](???*1*) +1862 -> 1930 member call = ???*0*["push"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1371 -> 1442 member call = ???*0*["focus"]() +1862 -> 1933 member call = ???*0*["focus"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1451 free var = FreeVar(document) +0 -> 1942 free var = FreeVar(document) -0 -> 1453 free var = FreeVar(document) +0 -> 1944 free var = FreeVar(document) -0 -> 1455 conditional = (???*0* === ???*2*) +0 -> 1946 conditional = (???*0* === ???*2*) - *0* ???*1*["window"] ⚠️ unknown object - *1* arguments[2] @@ -8105,17 +11350,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -1455 -> 1458 conditional = (9 === ???*0*) +1946 -> 1949 conditional = (9 === ???*0*) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 1460 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])(???*0*) +0 -> 1951 call = (...) => (undefined | null | (a["activeElement"] || a["body"]) | a["body"])(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1461 call = (...) => ( +0 -> 1952 call = (...) => ( && b && ( || ( @@ -8135,67 +11380,86 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1462 conditional = ???*0* +0 -> 1953 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1462 -> 1469 free var = FreeVar(window) +1953 -> 1960 free var = FreeVar(window) -1462 -> 1470 member call = ???*0*["getSelection"]() +1953 -> 1961 member call = ???*0*["getSelection"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1475 call = (...) => (!(0) | !(1))(???*0*, ???*1*) +0 -> 1966 call = (...) => (!(0) | !(1))(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1476 call = (...) => d(???*0*, "onSelect") +0 -> 1967 call = (...) => d(???*0*, "onSelect") - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1479 member call = ???*0*["push"](???*1*) +0 -> 1970 member call = ???*0*["push"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1483 member call = ???*0*["toLowerCase"]() +0 -> 1974 member call = ???*0*["toLowerCase"]() - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1485 member call = ???*0*["toLowerCase"]() +0 -> 1976 member call = ???*0*["toLowerCase"]() - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1488 call = (...) => c("Animation", "AnimationEnd") +0 -> 1979 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 1980 call = (...) => c("Animation", "AnimationEnd") -0 -> 1489 call = (...) => c("Animation", "AnimationIteration") +0 -> 1981 call = (...) => c("Animation", "AnimationIteration") -0 -> 1490 call = (...) => c("Animation", "AnimationStart") +0 -> 1982 call = (...) => c("Animation", "AnimationStart") -0 -> 1491 call = (...) => c("Transition", "TransitionEnd") +0 -> 1983 call = (...) => c("Transition", "TransitionEnd") -0 -> 1494 free var = FreeVar(document) +0 -> 1986 free var = FreeVar(document) -0 -> 1495 member call = ???*0*["createElement"]("div") +0 -> 1987 member call = ???*0*["createElement"]("div") - *0* FreeVar(document) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1496 free var = FreeVar(window) +0 -> 1988 free var = FreeVar(window) -0 -> 1503 free var = FreeVar(window) +0 -> 1995 free var = FreeVar(window) -0 -> 1507 conditional = ???*0* +0 -> 1999 conditional = ???*0* - *0* {}[???*1*] ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1512 member call = ({} | ???*0*)["hasOwnProperty"](???*2*) +1999 -> 2001 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +1999 -> 2003 conditional = !(({} | ???*0*)) +- *0* {}[???*1*] + ⚠️ unknown object prototype methods or values + ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +2003 -> 2004 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2003 -> 2007 member call = ({} | ???*0*)["hasOwnProperty"](???*2*) - *0* {}[???*1*] ⚠️ unknown object prototype methods or values ⚠️ This value might have side effects @@ -8204,7 +11468,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* c ⚠️ pattern without value -0 -> 1513 conditional = (???*0* | ???*4* | ???*8*) +2003 -> 2008 conditional = (???*0* | ???*4* | ???*8*) - *0* (???*1* | ???*2*)(???*3*) ⚠️ non-function callee - *1* FreeVar(undefined) @@ -8227,27 +11491,35 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unsupported expression ⚠️ This value might have side effects -0 -> 1516 call = (...) => (Xe[a] | a | ???*0*)("animationend") +2008 -> 2011 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2008 -> 2012 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2013 call = (...) => (Xe[a] | a | ???*0*)("animationend") - *0* unsupported expression ⚠️ This value might have side effects -0 -> 1517 call = (...) => (Xe[a] | a | ???*0*)("animationiteration") +0 -> 2014 call = (...) => (Xe[a] | a | ???*0*)("animationiteration") - *0* unsupported expression ⚠️ This value might have side effects -0 -> 1518 call = (...) => (Xe[a] | a | ???*0*)("animationstart") +0 -> 2015 call = (...) => (Xe[a] | a | ???*0*)("animationstart") - *0* unsupported expression ⚠️ This value might have side effects -0 -> 1519 call = (...) => (Xe[a] | a | ???*0*)("transitionend") +0 -> 2016 call = (...) => (Xe[a] | a | ???*0*)("transitionend") - *0* unsupported expression ⚠️ This value might have side effects -0 -> 1520 free var = FreeVar(Map) +0 -> 2017 free var = FreeVar(Map) -0 -> 1522 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ") +0 -> 2019 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ") -0 -> 1524 member call = ???*0*["set"](???*1*, ???*2*) +0 -> 2021 member call = ???*0*["set"](???*1*, ???*2*) - *0* unknown new expression ⚠️ This value might have side effects - *1* arguments[0] @@ -8255,25 +11527,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1525 call = (...) => undefined(???*0*, [???*1*]) +0 -> 2022 call = (...) => undefined(???*0*, [???*1*]) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1529 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ")[(0 | ???*0*)]["toLowerCase"]() +0 -> 2026 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ")[(0 | ???*0*)]["toLowerCase"]() - *0* updated with update expression ⚠️ This value might have side effects -0 -> 1532 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ")[(0 | ???*0*)][0]["toUpperCase"]() +0 -> 2029 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ")[(0 | ???*0*)][0]["toUpperCase"]() - *0* updated with update expression ⚠️ This value might have side effects -0 -> 1534 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ")[(0 | ???*0*)]["slice"](1) +0 -> 2031 member call = "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel"["split"](" ")[(0 | ???*0*)]["slice"](1) - *0* updated with update expression ⚠️ This value might have side effects -0 -> 1535 call = (...) => undefined(???*0*(), `on${???*4*}`) +0 -> 2032 call = (...) => undefined(???*0*(), `on${???*4*}`) - *0* ???*1*["toLowerCase"] ⚠️ unknown object ⚠️ This value might have side effects @@ -8311,7 +11583,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* updated with update expression ⚠️ This value might have side effects -0 -> 1536 call = (...) => undefined((???*0* | ???*1* | "animationend" | ???*2*), "onAnimationEnd") +0 -> 2033 call = (...) => undefined((???*0* | ???*1* | "animationend" | ???*2*), "onAnimationEnd") - *0* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects @@ -8320,7 +11592,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 1537 call = (...) => undefined((???*0* | ???*1* | "animationiteration" | ???*2*), "onAnimationIteration") +0 -> 2034 call = (...) => undefined((???*0* | ???*1* | "animationiteration" | ???*2*), "onAnimationIteration") - *0* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects @@ -8329,7 +11601,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 1538 call = (...) => undefined((???*0* | ???*1* | "animationstart" | ???*2*), "onAnimationStart") +0 -> 2035 call = (...) => undefined((???*0* | ???*1* | "animationstart" | ???*2*), "onAnimationStart") - *0* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects @@ -8338,13 +11610,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 1539 call = (...) => undefined("dblclick", "onDoubleClick") +0 -> 2036 call = (...) => undefined("dblclick", "onDoubleClick") -0 -> 1540 call = (...) => undefined("focusin", "onFocus") +0 -> 2037 call = (...) => undefined("focusin", "onFocus") -0 -> 1541 call = (...) => undefined("focusout", "onBlur") +0 -> 2038 call = (...) => undefined("focusout", "onBlur") -0 -> 1542 call = (...) => undefined((???*0* | ???*1* | "transitionend" | ???*2*), "onTransitionEnd") +0 -> 2039 call = (...) => undefined((???*0* | ???*1* | "transitionend" | ???*2*), "onTransitionEnd") - *0* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects @@ -8353,65 +11625,65 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 1543 call = (...) => undefined("onMouseEnter", ["mouseout", "mouseover"]) +0 -> 2040 call = (...) => undefined("onMouseEnter", ["mouseout", "mouseover"]) -0 -> 1544 call = (...) => undefined("onMouseLeave", ["mouseout", "mouseover"]) +0 -> 2041 call = (...) => undefined("onMouseLeave", ["mouseout", "mouseover"]) -0 -> 1545 call = (...) => undefined("onPointerEnter", ["pointerout", "pointerover"]) +0 -> 2042 call = (...) => undefined("onPointerEnter", ["pointerout", "pointerover"]) -0 -> 1546 call = (...) => undefined("onPointerLeave", ["pointerout", "pointerover"]) +0 -> 2043 call = (...) => undefined("onPointerLeave", ["pointerout", "pointerover"]) -0 -> 1548 member call = "change click focusin focusout input keydown keyup selectionchange"["split"](" ") +0 -> 2045 member call = "change click focusin focusout input keydown keyup selectionchange"["split"](" ") -0 -> 1549 call = (...) => undefined( +0 -> 2046 call = (...) => undefined( "onChange", "change click focusin focusout input keydown keyup selectionchange"["split"](" ") ) -0 -> 1551 member call = "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange"["split"](" ") +0 -> 2048 member call = "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange"["split"](" ") -0 -> 1552 call = (...) => undefined( +0 -> 2049 call = (...) => undefined( "onSelect", "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange"["split"](" ") ) -0 -> 1553 call = (...) => undefined( +0 -> 2050 call = (...) => undefined( "onBeforeInput", ["compositionend", "keypress", "textInput", "paste"] ) -0 -> 1555 member call = "compositionend focusout keydown keypress keyup mousedown"["split"](" ") +0 -> 2052 member call = "compositionend focusout keydown keypress keyup mousedown"["split"](" ") -0 -> 1556 call = (...) => undefined( +0 -> 2053 call = (...) => undefined( "onCompositionEnd", "compositionend focusout keydown keypress keyup mousedown"["split"](" ") ) -0 -> 1558 member call = "compositionstart focusout keydown keypress keyup mousedown"["split"](" ") +0 -> 2055 member call = "compositionstart focusout keydown keypress keyup mousedown"["split"](" ") -0 -> 1559 call = (...) => undefined( +0 -> 2056 call = (...) => undefined( "onCompositionStart", "compositionstart focusout keydown keypress keyup mousedown"["split"](" ") ) -0 -> 1561 member call = "compositionupdate focusout keydown keypress keyup mousedown"["split"](" ") +0 -> 2058 member call = "compositionupdate focusout keydown keypress keyup mousedown"["split"](" ") -0 -> 1562 call = (...) => undefined( +0 -> 2059 call = (...) => undefined( "onCompositionUpdate", "compositionupdate focusout keydown keypress keyup mousedown"["split"](" ") ) -0 -> 1564 member call = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting"["split"](" ") +0 -> 2061 member call = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting"["split"](" ") -0 -> 1565 free var = FreeVar(Set) +0 -> 2062 free var = FreeVar(Set) -0 -> 1568 member call = "cancel close invalid load scroll toggle"["split"](" ") +0 -> 2065 member call = "cancel close invalid load scroll toggle"["split"](" ") -0 -> 1569 member call = "cancel close invalid load scroll toggle"["split"](" ")["concat"]( +0 -> 2066 member call = "cancel close invalid load scroll toggle"["split"](" ")["concat"]( "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting"["split"](" ") ) -0 -> 1572 call = (...) => undefined((???*0* | "unknown-event"){truthy}, ???*2*, ???*3*, ???*4*) +0 -> 2069 call = (...) => undefined((???*0* | "unknown-event"){truthy}, ???*2*, ???*3*, ???*4*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] @@ -8423,13 +11695,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1578 conditional = (???*0* | (0 !== ???*1*)) +0 -> 2075 conditional = (???*0* | (0 !== ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unsupported expression ⚠️ This value might have side effects -1578 -> 1585 member call = (???*0* | null[(0 | ???*4*)]["event"] | ???*5*)["isPropagationStopped"]() +2075 -> 2082 member call = (???*0* | null[(0 | ???*4*)]["event"] | ???*5*)["isPropagationStopped"]() - *0* ???*1*["event"] ⚠️ unknown object ⚠️ This value might have side effects @@ -8449,7 +11721,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* d ⚠️ circular variable reference -1578 -> 1586 call = (...) => undefined( +2075 -> 2083 call = (...) => undefined( (???*0* | null[(0 | ???*4*)]["event"] | ???*5*), (???*8* | null[(0 | ???*14*)][(???*15* | ???*16* | 0)] | ???*17*), ( @@ -8530,7 +11802,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *31* h ⚠️ circular variable reference -1578 -> 1593 member call = (???*0* | null[(0 | ???*4*)]["event"] | ???*5*)["isPropagationStopped"]() +2075 -> 2090 member call = (???*0* | null[(0 | ???*4*)]["event"] | ???*5*)["isPropagationStopped"]() - *0* ???*1*["event"] ⚠️ unknown object ⚠️ This value might have side effects @@ -8550,7 +11822,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* d ⚠️ circular variable reference -1578 -> 1594 call = (...) => undefined( +2075 -> 2091 call = (...) => undefined( (???*0* | null[(0 | ???*4*)]["event"] | ???*5*), (???*8* | null[(0 | ???*14*)][(???*15* | ???*16* | 0)] | ???*17*), ( @@ -8631,9 +11903,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *31* h ⚠️ circular variable reference -0 -> 1597 free var = FreeVar(Set) +0 -> 2094 free var = FreeVar(Set) -0 -> 1599 member call = (???*0* | ???*2*)["has"](`${???*3*}__bubble`) +0 -> 2096 member call = (???*0* | ???*2*)["has"](`${???*3*}__bubble`) - *0* ???*1*[of] ⚠️ unknown object - *1* arguments[1] @@ -8643,13 +11915,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1600 call = (...) => undefined(???*0*, ???*1*, 2, false) +0 -> 2097 call = (...) => undefined(???*0*, ???*1*, 2, false) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1602 member call = (???*0* | ???*2*)["add"](`${???*3*}__bubble`) +0 -> 2099 member call = (???*0* | ???*2*)["add"](`${???*3*}__bubble`) - *0* ???*1*[of] ⚠️ unknown object - *1* arguments[1] @@ -8659,7 +11931,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1603 call = (...) => undefined(???*0*, ???*1*, (0 | ???*2*), ???*3*) +0 -> 2100 call = (...) => undefined(???*0*, ???*1*, (0 | ???*2*), ???*3*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[0] @@ -8669,14 +11941,14 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1607 free var = FreeVar(Math) +0 -> 2104 free var = FreeVar(Math) -0 -> 1608 member call = ???*0*["random"]() +0 -> 2105 member call = ???*0*["random"]() - *0* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1609 member call = ???*0*()["toString"](36) +0 -> 2106 member call = ???*0*()["toString"](36) - *0* ???*1*["random"] ⚠️ unknown object ⚠️ This value might have side effects @@ -8684,7 +11956,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1610 member call = ???*0*["slice"](2) +0 -> 2107 member call = ???*0*["slice"](2) - *0* ???*1*(36) ⚠️ unknown callee - *1* ???*2*["toString"] @@ -8698,41 +11970,41 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1612 conditional = !(???*0*) +0 -> 2109 conditional = !(???*0*) - *0* ???*1*[rf] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -1612 -> 1615 member call = ???*0*["forEach"]((...) => undefined) +2109 -> 2112 member call = ???*0*["forEach"]((...) => undefined) - *0* unknown new expression ⚠️ This value might have side effects -1615 -> 1617 member call = ???*0*["has"](???*1*) +2112 -> 2114 member call = ???*0*["has"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -1615 -> 1618 call = (...) => undefined(???*0*, false, ???*1*) +2112 -> 2115 call = (...) => undefined(???*0*, false, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -1615 -> 1619 call = (...) => undefined(???*0*, true, ???*1*) +2112 -> 2116 call = (...) => undefined(???*0*, true, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -1612 -> 1621 conditional = (9 === ???*0*) +2109 -> 2118 conditional = (9 === ???*0*) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -1612 -> 1625 call = (...) => undefined("selectionchange", false, (???*0* ? ???*3* : ???*4*)) +2109 -> 2122 call = (...) => undefined("selectionchange", false, (???*0* ? ???*3* : ???*4*)) - *0* (9 === ???*1*) ⚠️ nested operation - *1* ???*2*["nodeType"] @@ -8746,11 +12018,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1626 call = (...) => (undefined | 1 | 4 | 16 | 536870912)(???*0*) +0 -> 2123 call = (...) => (undefined | 1 | 4 | 16 | 536870912)(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1628 member call = ((...) => undefined | ???*0* | true)["bind"]( +0 -> 2125 member call = ((...) => undefined | ???*0* | true)["bind"]( null, ???*1*, ( @@ -8793,17 +12065,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1629 conditional = ???*0* +0 -> 2126 conditional = ???*0* - *0* arguments[3] ⚠️ function calls are not analysed yet -1629 -> 1630 conditional = (???*0* !== ((...) => undefined | ???*1* | true)) +2126 -> 2127 conditional = (???*0* !== ((...) => undefined | ???*1* | true)) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -1630 -> 1632 member call = ???*0*["addEventListener"]( +2127 -> 2129 member call = ???*0*["addEventListener"]( ???*1*, ( | ???*2* @@ -8845,7 +12117,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* unsupported expression ⚠️ This value might have side effects -1630 -> 1634 member call = ???*0*["addEventListener"]( +2127 -> 2131 member call = ???*0*["addEventListener"]( ???*1*, ( | ???*2* @@ -8885,13 +12157,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* arguments[0] ⚠️ function calls are not analysed yet -1629 -> 1635 conditional = (???*0* !== ((...) => undefined | ???*1* | true)) +2126 -> 2132 conditional = (???*0* !== ((...) => undefined | ???*1* | true)) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -1635 -> 1637 member call = ???*0*["addEventListener"]( +2132 -> 2134 member call = ???*0*["addEventListener"]( ???*1*, ( | ???*2* @@ -8933,7 +12205,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* unsupported expression ⚠️ This value might have side effects -1635 -> 1639 member call = ???*0*["addEventListener"]( +2132 -> 2136 member call = ???*0*["addEventListener"]( ???*1*, ( | ???*2* @@ -8973,7 +12245,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1640 conditional = ((0 === ???*0*) | (null !== (???*1* | ???*2* | ???*3*))) +0 -> 2137 conditional = ((0 === ???*0*) | (null !== (???*1* | ???*2* | ???*3*))) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[3] @@ -8985,19 +12257,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* d ⚠️ circular variable reference -1640 -> 1642 conditional = ???*0* +2137 -> 2138 conditional = (null === (???*0* | ???*1* | ???*2*)) +- *0* arguments[3] + ⚠️ function calls are not analysed yet +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* ???*3*["return"] + ⚠️ unknown object +- *3* d + ⚠️ circular variable reference + +2138 -> 2139 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2138 -> 2141 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1642 -> 1647 conditional = ???*0* +2141 -> 2146 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1647 -> 1650 conditional = ???*0* +2146 -> 2149 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1642 -> 1656 call = (...) => (b | c | null)((???*0* | ???*3*)) +2149 -> 2154 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2141 -> 2156 call = (...) => (b | c | null)((???*0* | ???*3*)) - *0* ???*1*["containerInfo"] ⚠️ unknown object - *1* ???*2*["stateNode"] @@ -9013,43 +12303,51 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unsupported expression ⚠️ This value might have side effects -0 -> 1660 call = (...) => (undefined | a(b, c) | Gb(a, b, c))((...) => undefined) +2141 -> 2157 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +2157 -> 2158 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2162 call = (...) => (undefined | a(b, c) | Gb(a, b, c))((...) => undefined) -1660 -> 1661 call = (...) => ((3 === a["nodeType"]) ? a["parentNode"] : a)(???*0*) +2162 -> 2163 call = (...) => ((3 === a["nodeType"]) ? a["parentNode"] : a)(???*0*) - *0* arguments[2] ⚠️ function calls are not analysed yet -1660 -> 1663 member call = ???*0*["get"](???*1*) +2162 -> 2165 member call = ???*0*["get"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -1660 -> 1664 conditional = ???*0* +2162 -> 2166 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1664 -> 1665 call = (...) => ((???*0* || (13 === a)) ? a : 0)(???*1*) +2166 -> 2167 call = (...) => ((???*0* || (13 === a)) ? a : 0)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -1664 -> 1667 conditional = ???*0* +2166 -> 2169 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1667 -> 1668 conditional = ???*0* +2169 -> 2170 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1664 -> 1671 call = (...) => (null | c)(???*0*, ???*1*) +2166 -> 2173 call = (...) => (null | c)(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1664 -> 1673 call = (...) => {"instance": a, "listener": b, "currentTarget": c}(???*0*, ???*1*, ???*2*) +2166 -> 2175 call = (...) => {"instance": a, "listener": b, "currentTarget": c}(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -9057,29 +12355,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1664 -> 1674 member call = ???*0*["push"](???*1*) +2166 -> 2176 member call = ???*0*["push"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1664 -> 1678 member call = []["push"](???*0*) +2166 -> 2180 member call = []["push"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1660 -> 1679 conditional = (0 === ???*0*) +2162 -> 2181 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -1679 -> 1682 call = (...) => (b | c | null)(???*0*) +2181 -> 2184 call = (...) => (b | c | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1684 conditional = ???*0* +2181 -> 2186 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1684 -> 1686 conditional = ((???*0* | ???*15*) === (???*17* | ???*31*)) +2186 -> 2188 conditional = ((???*0* | ???*15*) === (???*17* | ???*31*)) - *0* ???*1*["window"] ⚠️ unknown object - *1* (???*2* ? (???*7* | ???*9*) : (???*11* | ???*12* | ???*14*)) @@ -9156,45 +12454,45 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *31* unknown new expression ⚠️ This value might have side effects -1686 -> 1690 free var = FreeVar(window) +2188 -> 2192 free var = FreeVar(window) -1684 -> 1691 conditional = ???*0* +2186 -> 2193 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1691 -> 1694 conditional = ???*0* +2193 -> 2196 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1694 -> 1695 call = (...) => (b | c | null)(???*0*) +2196 -> 2197 call = (...) => (b | c | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1691 -> 1696 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) +2193 -> 2198 call = (...) => ((3 === b["tag"]) ? c : null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1684 -> 1699 conditional = ???*0* +2186 -> 2201 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1699 -> 1700 conditional = ???*0* +2201 -> 2202 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1700 -> 1701 call = (...) => (undefined | a["stateNode"])(???*0*) +2202 -> 2203 call = (...) => (undefined | a["stateNode"])(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1699 -> 1702 conditional = ???*0* +2201 -> 2204 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1702 -> 1703 call = (...) => (undefined | a["stateNode"])(???*0*) +2204 -> 2205 call = (...) => (undefined | a["stateNode"])(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1699 -> 1706 call = (...) => (b | c | null)( +2201 -> 2208 call = (...) => (b | c | null)( ( | (???*0* ? (???*5* | ???*7*) : (???*9* | ???*10* | ???*12*)) | ???*13* @@ -9234,35 +12532,35 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* unknown new expression ⚠️ This value might have side effects -1699 -> 1709 conditional = ???*0* +2201 -> 2211 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1710 call = (...) => (null | (a ? a : null))(???*0*) +2211 -> 2212 call = (...) => (null | (a ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1711 call = (...) => (null | (a ? a : null))(???*0*) +2211 -> 2213 call = (...) => (null | (a ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1712 call = (...) => (null | (a ? a : null))(???*0*) +2211 -> 2214 call = (...) => (null | (a ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1713 call = (...) => (null | (a ? a : null))(???*0*) +2211 -> 2215 call = (...) => (null | (a ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1715 call = (...) => (null | (a ? a : null))(???*0*) +2211 -> 2217 call = (...) => (null | (a ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1709 -> 1716 call = (...) => (null | (a ? a : null))(???*0*) +2211 -> 2218 call = (...) => (null | (a ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1699 -> 1717 call = (...) => undefined([], ???*0*, ???*1*, ???*2*, false) +2201 -> 2219 call = (...) => undefined([], ???*0*, ???*1*, ???*2*, false) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -9270,7 +12568,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1699 -> 1718 call = (...) => undefined([], ???*0*, ???*1*, ???*2*, true) +2201 -> 2220 call = (...) => undefined([], ???*0*, ???*1*, ???*2*, true) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -9278,37 +12576,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1719 conditional = ???*0* +2181 -> 2221 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1719 -> 1720 call = (...) => (undefined | a["stateNode"])(???*0*) +2221 -> 2222 call = (...) => (undefined | a["stateNode"])(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1719 -> 1721 free var = FreeVar(window) +2221 -> 2223 free var = FreeVar(window) -1679 -> 1725 member call = ???*0*["toLowerCase"]() +2181 -> 2227 member call = ???*0*["toLowerCase"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1727 conditional = ???*0* +2181 -> 2229 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1727 -> 1728 call = (...) => (("input" === b) ? !(!(le[a["type"]])) : (("textarea" === b) ? !(0) : !(1)))(???*0*) +2229 -> 2230 call = (...) => (("input" === b) ? !(!(le[a["type"]])) : (("textarea" === b) ? !(0) : !(1)))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1727 -> 1729 conditional = ???*0* +2229 -> 2231 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1729 -> 1732 member call = ???*0*["toLowerCase"]() +2231 -> 2234 member call = ???*0*["toLowerCase"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1735 call = ( +2181 -> 2237 call = ( | (...) => (undefined | b) | (...) => (undefined | te(b)) | (...) => (undefined | te(qe)) @@ -9324,7 +12622,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1736 conditional = ( +2181 -> 2238 conditional = ( | (...) => (undefined | b) | (...) => (undefined | te(b)) | (...) => (undefined | te(qe)) @@ -9339,7 +12637,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -1736 -> 1737 call = (...) => undefined( +2238 -> 2239 call = (...) => undefined( [], ( | (...) => (undefined | b) @@ -9394,7 +12692,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* unknown new expression ⚠️ This value might have side effects -1679 -> 1738 call = ???*0*(???*1*, ???*2*, ???*3*) +2181 -> 2240 call = ???*0*(???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[0] @@ -9404,27 +12702,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1743 call = (...) => undefined(???*0*, "number", ???*1*) +2181 -> 2245 call = (...) => undefined(???*0*, "number", ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1744 conditional = ???*0* +2181 -> 2246 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1744 -> 1745 call = (...) => (undefined | a["stateNode"])(???*0*) +2246 -> 2247 call = (...) => (undefined | a["stateNode"])(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1744 -> 1746 free var = FreeVar(window) +2246 -> 2248 free var = FreeVar(window) -1679 -> 1747 call = (...) => (("input" === b) ? !(!(le[a["type"]])) : (("textarea" === b) ? !(0) : !(1)))(???*0*) +2181 -> 2249 call = (...) => (("input" === b) ? !(!(le[a["type"]])) : (("textarea" === b) ? !(0) : !(1)))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1749 call = (...) => undefined( +2181 -> 2251 call = (...) => undefined( [], ???*0*, ( @@ -9468,7 +12766,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* unknown new expression ⚠️ This value might have side effects -1679 -> 1750 call = (...) => undefined( +2181 -> 2252 call = (...) => undefined( [], ???*0*, ( @@ -9512,7 +12810,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* unknown new expression ⚠️ This value might have side effects -1679 -> 1751 conditional = (!(???*0*) | ???*3*) +2181 -> 2253 conditional = (!(???*0*) | ???*3*) - *0* ("undefined" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -9523,9 +12821,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -1751 -> 1752 conditional = (false | true) +2253 -> 2254 conditional = (false | true) -1752 -> 1753 call = (...) => (undefined | (???*0* !== $d["indexOf"](b["keyCode"])) | (229 !== b["keyCode"]) | !(0) | !(1))(???*1*, ???*2*) +2254 -> 2255 call = (...) => (undefined | (???*0* !== $d["indexOf"](b["keyCode"])) | (229 !== b["keyCode"]) | !(0) | !(1))(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] @@ -9533,7 +12831,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -1679 -> 1756 conditional = ( +2181 -> 2258 conditional = ( | false | true | ("onCompositionStart" !== ("onCompositionStart" | "onCompositionEnd" | "onCompositionUpdate" | ???*0* | ???*1*)) @@ -9543,11 +12841,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* unknown new expression ⚠️ This value might have side effects -1756 -> 1757 call = (...) => (md | ???*0*)() +2258 -> 2259 call = (...) => (md | ???*0*)() - *0* unsupported expression ⚠️ This value might have side effects -1679 -> 1760 call = (...) => d( +2181 -> 2262 call = (...) => d( ???*0*, ("onCompositionStart" | "onCompositionEnd" | "onCompositionUpdate" | ???*1* | ???*2*) ) @@ -9558,21 +12856,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unknown new expression ⚠️ This value might have side effects -1679 -> 1763 member call = []["push"](???*0*) +2181 -> 2265 member call = []["push"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1764 conditional = ???*0* +2181 -> 2266 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1764 -> 1766 call = (...) => ((("object" === typeof(a)) && ???*0*) ? a["data"] : null)(???*1*) +2266 -> 2268 call = (...) => ((("object" === typeof(a)) && ???*0*) ? a["data"] : null)(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -1679 -> 1768 conditional = (!(???*0*) | ???*3* | !((null | ???*4*))) +2181 -> 2270 conditional = (!(???*0*) | ???*3* | !((null | ???*4*))) - *0* ("undefined" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -9589,7 +12887,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1768 -> 1769 call = (...) => (undefined | he(b) | null | ee | ???*0*)(???*1*, ???*2*) +2270 -> 2271 call = (...) => (undefined | he(b) | null | ee | ???*0*)(???*1*, ???*2*) - *0* (((a === ee) && fe) ? null : a) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -9598,7 +12896,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -1768 -> 1770 call = (...) => ( +2270 -> 2272 call = (...) => ( | undefined | ((("compositionend" === a) || (!(ae) && ge(a, b))) ? ???*0* : null) | null @@ -9614,19 +12912,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -1679 -> 1771 call = (...) => d(???*0*, "onBeforeInput") +2181 -> 2273 call = (...) => d(???*0*, "onBeforeInput") - *0* max number of linking steps reached ⚠️ This value might have side effects -1679 -> 1774 member call = []["push"](???*0*) +2181 -> 2276 member call = []["push"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -1660 -> 1776 call = (...) => undefined([], ???*0*) +2162 -> 2278 call = (...) => undefined([], ???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1779 call = (...) => (null | c)((???*0* | ???*1*), `${???*3*}Capture`) +0 -> 2279 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2282 call = (...) => (null | c)((???*0* | ???*1*), `${???*3*}Capture`) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["return"] @@ -9636,7 +12938,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1781 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( +0 -> 2284 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( (???*0* | ???*1*), ( | ???*3* @@ -9811,11 +13113,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *71* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1782 member call = []["unshift"](???*0*) +0 -> 2285 member call = []["unshift"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1783 call = (...) => (null | c)((???*0* | ???*1*), ???*3*) +0 -> 2286 call = (...) => (null | c)((???*0* | ???*1*), ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["return"] @@ -9825,7 +13127,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1785 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( +0 -> 2288 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( (???*0* | ???*1*), ( | ???*3* @@ -10000,11 +13302,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *71* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1786 member call = []["push"](???*0*) +0 -> 2289 member call = []["push"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1790 conditional = (???*0* | ???*1*) +0 -> 2291 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2292 conditional = (null === (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["return"] @@ -10012,11 +13318,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* a ⚠️ circular variable reference -0 -> 1795 conditional = ???*0* +2292 -> 2293 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2292 -> 2296 conditional = (???*0* | ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference + +2292 -> 2297 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2302 conditional = ???*0* - *0* arguments[4] ⚠️ function calls are not analysed yet -1795 -> 1796 call = (...) => (null | c)((???*0* | ???*1*), ???*3*) +2302 -> 2303 call = (...) => (null | c)((???*0* | ???*1*), ???*3*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["return"] @@ -10028,7 +13350,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -1795 -> 1798 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( +2302 -> 2305 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( (???*0* | ???*1*), ( | ???*3* @@ -10096,7 +13418,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* c ⚠️ circular variable reference -1795 -> 1799 member call = []["unshift"]( +2302 -> 2306 member call = []["unshift"]( { "instance": (???*0* | ???*1*), "listener": ( @@ -10166,7 +13488,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* c ⚠️ circular variable reference -1795 -> 1800 call = (...) => (null | c)((???*0* | ???*1*), ???*3*) +2302 -> 2307 call = (...) => (null | c)((???*0* | ???*1*), ???*3*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["return"] @@ -10178,7 +13500,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -1795 -> 1802 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( +2302 -> 2309 call = (...) => {"instance": a, "listener": b, "currentTarget": c}( (???*0* | ???*1*), ( | ???*3* @@ -10246,7 +13568,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* c ⚠️ circular variable reference -1795 -> 1803 member call = []["push"]( +2302 -> 2310 member call = []["push"]( { "instance": (???*0* | ???*1*), "listener": ( @@ -10316,19 +13638,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* c ⚠️ circular variable reference -0 -> 1807 member call = ???*0*["push"]({"event": ???*1*, "listeners": []}) +0 -> 2314 member call = ???*0*["push"]({"event": ???*1*, "listeners": []}) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1810 conditional = ("string" === ???*0*) +0 -> 2317 conditional = ("string" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1811 member call = (???*0* ? ???*3* : ???*4*)["replace"](/\r\n?/g, "\n") +0 -> 2318 member call = (???*0* ? ???*3* : ???*4*)["replace"](/\r\n?/g, "\n") - *0* ("string" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -10340,7 +13662,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1812 member call = ???*0*["replace"](/\u0000|\uFFFD/g, "") +0 -> 2319 member call = ???*0*["replace"](/\u0000|\uFFFD/g, "") - *0* ???*1*(/\r\n?/g, "\n") ⚠️ unknown callee - *1* ???*2*["replace"] @@ -10356,7 +13678,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1813 call = (...) => (("string" === typeof(a)) ? a : `${a}`)["replace"](xf, "\n")["replace"](yf, "")((???*0* | ???*1*)) +0 -> 2320 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2321 call = (...) => (("string" === typeof(a)) ? a : `${a}`)["replace"](xf, "\n")["replace"](yf, "")((???*0* | ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["replace"](yf, "") @@ -10374,11 +13700,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* b ⚠️ circular variable reference -0 -> 1814 call = (...) => (("string" === typeof(a)) ? a : `${a}`)["replace"](xf, "\n")["replace"](yf, "")(???*0*) +0 -> 2322 call = (...) => (("string" === typeof(a)) ? a : `${a}`)["replace"](xf, "\n")["replace"](yf, "")(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1815 conditional = ((???*0* !== (???*7* | ???*8*)) | ???*15*) +0 -> 2323 conditional = ((???*0* !== (???*7* | ???*8*)) | ???*15*) - *0* ???*1*["replace"](yf, "") ⚠️ unknown callee object - *1* ???*2*(/\r\n?/g, "\n") @@ -10412,11 +13738,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* arguments[2] ⚠️ function calls are not analysed yet -1815 -> 1816 free var = FreeVar(Error) +2323 -> 2324 free var = FreeVar(Error) -1815 -> 1817 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(425) +2323 -> 2325 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(425) -1815 -> 1818 call = ???*0*( +2323 -> 2326 call = ???*0*( `Minified React error #${425}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -10425,51 +13751,55 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${425}` ⚠️ nested operation -0 -> 1825 free var = FreeVar(setTimeout) +0 -> 2333 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2334 free var = FreeVar(setTimeout) -0 -> 1826 conditional = ("function" === ???*0*) +0 -> 2335 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(setTimeout) ⚠️ unknown global ⚠️ This value might have side effects -1826 -> 1827 free var = FreeVar(setTimeout) +2335 -> 2336 free var = FreeVar(setTimeout) -0 -> 1828 free var = FreeVar(clearTimeout) +0 -> 2337 free var = FreeVar(clearTimeout) -0 -> 1829 conditional = ("function" === ???*0*) +0 -> 2338 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(clearTimeout) ⚠️ unknown global ⚠️ This value might have side effects -1829 -> 1830 free var = FreeVar(clearTimeout) +2338 -> 2339 free var = FreeVar(clearTimeout) -0 -> 1831 free var = FreeVar(Promise) +0 -> 2340 free var = FreeVar(Promise) -0 -> 1832 conditional = ("function" === ???*0*) +0 -> 2341 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(Promise) ⚠️ unknown global ⚠️ This value might have side effects -1832 -> 1833 free var = FreeVar(Promise) +2341 -> 2342 free var = FreeVar(Promise) -0 -> 1834 free var = FreeVar(queueMicrotask) +0 -> 2343 free var = FreeVar(queueMicrotask) -0 -> 1835 conditional = ("function" === ???*0*) +0 -> 2344 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(queueMicrotask) ⚠️ unknown global ⚠️ This value might have side effects -1835 -> 1836 free var = FreeVar(queueMicrotask) +2344 -> 2345 free var = FreeVar(queueMicrotask) -1835 -> 1837 conditional = ("undefined" !== ???*0*) +2344 -> 2346 conditional = ("undefined" !== ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* (???*2* ? ???*5* : ???*6*) @@ -10487,7 +13817,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* unsupported expression ⚠️ This value might have side effects -1837 -> 1841 member call = (???*0* ? ???*3* : ???*4*)["resolve"](null) +2346 -> 2350 member call = (???*0* ? ???*3* : ???*4*)["resolve"](null) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -10501,7 +13831,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -1837 -> 1842 member call = ???*0*["then"](???*7*) +2346 -> 2351 member call = ???*0*["then"](???*7*) - *0* ???*1*(null) ⚠️ unknown callee - *1* ???*2*["resolve"] @@ -10520,7 +13850,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[0] ⚠️ function calls are not analysed yet -1837 -> 1843 member call = ???*0*["catch"]((...) => undefined) +2346 -> 2352 member call = ???*0*["catch"]((...) => undefined) - *0* ???*1*["then"](a) ⚠️ unknown callee object - *1* ???*2*(null) @@ -10537,14 +13867,18 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* unsupported expression ⚠️ This value might have side effects -0 -> 1844 free var = FreeVar(setTimeout) +2346 -> 2353 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1845 call = ???*0*((...) => undefined) +0 -> 2354 free var = FreeVar(setTimeout) + +0 -> 2355 call = ???*0*((...) => undefined) - *0* FreeVar(setTimeout) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1848 member call = ???*0*["removeChild"]((???*1* | ???*2*)) +0 -> 2358 member call = ???*0*["removeChild"]((???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -10556,7 +13890,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* c ⚠️ circular variable reference -0 -> 1850 conditional = (???*0* | (8 === ???*2*)) +0 -> 2360 conditional = (???*0* | (8 === ???*2*)) - *0* ???*1*["nextSibling"] ⚠️ unknown object - *1* arguments[1] @@ -10568,11 +13902,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -1850 -> 1852 conditional = (0 === (0 | ???*0*)) +2360 -> 2362 conditional = (0 === (0 | ???*0*)) - *0* updated with update expression ⚠️ This value might have side effects -1852 -> 1854 member call = ???*0*["removeChild"](???*1*) +2362 -> 2364 member call = ???*0*["removeChild"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["nextSibling"] @@ -10580,34 +13914,78 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -1852 -> 1855 call = (...) => undefined(???*0*) +2362 -> 2365 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1856 call = (...) => undefined(???*0*) +2362 -> 2366 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2367 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1859 conditional = (8 === ???*0*) +0 -> 2370 conditional = (8 === ???*0*) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1863 conditional = (8 === ???*0*) +2370 -> 2372 conditional = ("/$" === ???*0*) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1869 free var = FreeVar(Math) +2372 -> 2373 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2374 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2377 conditional = (8 === ???*0*) +- *0* ???*1*["nodeType"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +2377 -> 2379 conditional = (("$" === ???*0*) | ("$!" === ???*2*) | ("$?" === ???*4*)) +- *0* ???*1*["data"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["data"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["data"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet + +2379 -> 2380 conditional = (0 === (0 | ???*0*)) +- *0* updated with update expression + ⚠️ This value might have side effects + +2380 -> 2381 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2383 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2387 free var = FreeVar(Math) -0 -> 1870 member call = ???*0*["random"]() +0 -> 2388 member call = ???*0*["random"]() - *0* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1871 member call = ???*0*()["toString"](36) +0 -> 2389 member call = ???*0*()["toString"](36) - *0* ???*1*["random"] ⚠️ unknown object ⚠️ This value might have side effects @@ -10615,7 +13993,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1872 member call = ???*0*["slice"](2) +0 -> 2390 member call = ???*0*["slice"](2) - *0* ???*1*(36) ⚠️ unknown callee - *1* ???*2*["toString"] @@ -10629,11 +14007,113 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 1880 conditional = ???*0* +0 -> 2392 conditional = ( + | ???*0* + | null[`__reactFiber$${???*6*}`] + | null["parentNode"][`__reactContainer$${???*11*}`] + | null[`__reactFiber$${???*16*}`][`__reactContainer$${???*21*}`] + | null["parentNode"][`__reactFiber$${???*26*}`] + | null[`__reactFiber$${???*31*}`][`__reactFiber$${???*36*}`] +) +- *0* ???*1*[`__reactFiber$${???*2*}`] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["slice"](2) + ⚠️ unknown callee object +- *3* ???*4*(36) + ⚠️ unknown callee +- *4* ???*5*["toString"] + ⚠️ unknown object +- *5* ???() + ⚠️ nested operation +- *6* ???*7*["slice"](2) + ⚠️ unknown callee object +- *7* ???*8*(36) + ⚠️ unknown callee +- *8* ???*9*["toString"] + ⚠️ unknown object +- *9* ???*10*() + ⚠️ nested operation +- *10* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *11* ???*12*["slice"](2) + ⚠️ unknown callee object +- *12* ???*13*(36) + ⚠️ unknown callee +- *13* ???*14*["toString"] + ⚠️ unknown object +- *14* ???*15*() + ⚠️ nested operation +- *15* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *16* ???*17*["slice"](2) + ⚠️ unknown callee object +- *17* ???*18*(36) + ⚠️ unknown callee +- *18* ???*19*["toString"] + ⚠️ unknown object +- *19* ???*20*() + ⚠️ nested operation +- *20* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *21* ???*22*["slice"](2) + ⚠️ unknown callee object +- *22* ???*23*(36) + ⚠️ unknown callee +- *23* ???*24*["toString"] + ⚠️ unknown object +- *24* ???*25*() + ⚠️ nested operation +- *25* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *26* ???*27*["slice"](2) + ⚠️ unknown callee object +- *27* ???*28*(36) + ⚠️ unknown callee +- *28* ???*29*["toString"] + ⚠️ unknown object +- *29* ???*30*() + ⚠️ nested operation +- *30* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *31* ???*32*["slice"](2) + ⚠️ unknown callee object +- *32* ???*33*(36) + ⚠️ unknown callee +- *33* ???*34*["toString"] + ⚠️ unknown object +- *34* ???*35*() + ⚠️ nested operation +- *35* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *36* ???*37*["slice"](2) + ⚠️ unknown callee object +- *37* ???*38*(36) + ⚠️ unknown callee +- *38* ???*39*["toString"] + ⚠️ unknown object +- *39* ???*40*() + ⚠️ nested operation +- *40* ???["random"] + ⚠️ unknown object + ⚠️ This value might have side effects + +2392 -> 2393 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2392 -> 2400 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -1880 -> 1881 call = (...) => (a | null)((???*0* | ???*1* | ???*2* | null)) +2400 -> 2401 call = (...) => (a | null)((???*0* | ???*1* | ???*2* | null)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a @@ -10643,7 +14123,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* a ⚠️ circular variable reference -1880 -> 1883 call = (...) => (a | null)((???*0* | ???*1* | ???*2* | null)) +2400 -> 2403 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2400 -> 2404 call = (...) => (a | null)((???*0* | ???*1* | ???*2* | null)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a @@ -10653,7 +14137,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* a ⚠️ circular variable reference -0 -> 1891 conditional = (!((???*0* | ???*1*)) | (5 !== ???*3*) | (6 !== ???*5*) | (13 !== ???*7*) | (3 !== ???*9*)) +2392 -> 2405 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2407 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2414 conditional = (!((???*0* | ???*1*)) | (5 !== ???*3*) | (6 !== ???*5*) | (13 !== ???*7*) | (3 !== ???*9*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*[Of] @@ -10677,7 +14169,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1894 conditional = ((5 === ???*0*) | (6 === ???*2*)) +0 -> 2415 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2418 conditional = ((5 === ???*0*) | (6 === ???*2*)) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] @@ -10687,11 +14183,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1896 free var = FreeVar(Error) +2418 -> 2420 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2418 -> 2421 free var = FreeVar(Error) -0 -> 1897 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(33) +2418 -> 2422 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(33) -0 -> 1898 call = ???*0*( +2418 -> 2423 call = ???*0*( `Minified React error #${33}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -10700,11 +14200,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${33}` ⚠️ nested operation -0 -> 1906 call = (...) => {"current": a}({}) +0 -> 2425 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2426 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1907 call = (...) => {"current": a}(false) +0 -> 2433 call = (...) => {"current": a}({}) -0 -> 1912 conditional = (???*0* | (???*2* === ???*5*)) +0 -> 2434 call = (...) => {"current": a}(false) + +0 -> 2437 conditional = !(???*0*) +- *0* ???*1*["contextTypes"] + ⚠️ unknown object +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +2437 -> 2438 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2437 -> 2441 conditional = (???*0* | (???*2* === ???*5*)) - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] @@ -10718,19 +14238,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1920 call = (...) => undefined({"current": false}) +2441 -> 2443 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2441 -> 2449 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2451 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 1921 call = (...) => undefined({"current": {}}) +0 -> 2452 call = (...) => undefined({"current": false}) -0 -> 1923 conditional = (({} | ???*0*) !== {}) +0 -> 2453 call = (...) => undefined({"current": {}}) + +0 -> 2455 conditional = (({} | ???*0*) !== {}) - *0* unknown mutation ⚠️ This value might have side effects -1923 -> 1924 free var = FreeVar(Error) +2455 -> 2456 free var = FreeVar(Error) -1923 -> 1925 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(168) +2455 -> 2457 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(168) -1923 -> 1926 call = ???*0*( +2455 -> 2458 call = ???*0*( `Minified React error #${168}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -10739,15 +14271,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${168}` ⚠️ nested operation -0 -> 1927 call = (...) => undefined({"current": {}}, ???*0*) +0 -> 2459 call = (...) => undefined({"current": {}}, ???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1928 call = (...) => undefined({"current": false}, ???*0*) +0 -> 2460 call = (...) => undefined({"current": false}, ???*0*) - *0* arguments[2] ⚠️ function calls are not analysed yet -0 -> 1933 member call = (???*0* | ???*2*())["getChildContext"]() +0 -> 2464 conditional = ("function" !== ???*0*) +- *0* typeof(???*1*) + ⚠️ nested operation +- *1* ???*2*["getChildContext"] + ⚠️ unknown object +- *2* ???*3*["stateNode"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +2464 -> 2465 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2464 -> 2467 member call = (???*0* | ???*2*())["getChildContext"]() - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] @@ -10757,13 +14303,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* d ⚠️ circular variable reference -0 -> 1934 conditional = !(???*0*) +2464 -> 2468 conditional = !(???*0*) - *0* unsupported expression ⚠️ This value might have side effects -1934 -> 1935 free var = FreeVar(Error) +2468 -> 2469 free var = FreeVar(Error) -1934 -> 1936 call = (...) => ( +2468 -> 2470 call = (...) => ( | "Cache" | `${(b["displayName"] || "Context")}.Consumer` | `${(b["_context"]["displayName"] || "Context")}.Provider` @@ -10794,20 +14340,20 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* arguments[0] ⚠️ function calls are not analysed yet -1934 -> 1937 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(108, ???*0*, ???*1*) +2468 -> 2471 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(108, ???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* e ⚠️ pattern without value -1934 -> 1938 call = ???*0*(???*1*) +2468 -> 2472 call = ???*0*(???*1*) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1939 call = ???*0*({}, ???*2*, (???*3* | ???*5*())) +2464 -> 2473 call = ???*0*({}, ???*2*, (???*3* | ???*5*())) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -10825,7 +14371,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* d ⚠️ circular variable reference -0 -> 1943 call = (...) => undefined({"current": {}}, (???*0* | ???*1* | ???*2* | {})) +2464 -> 2474 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2478 call = (...) => undefined({"current": {}}, (???*0* | ???*1* | ???*2* | {})) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -10835,11 +14385,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* a ⚠️ circular variable reference -0 -> 1945 call = (...) => undefined({"current": false}, (false | ???*0*)) +0 -> 2480 call = (...) => undefined({"current": false}, (false | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -0 -> 1947 conditional = !((???*0* | ???*2* | ???*3* | ???*4*)) +0 -> 2481 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2483 conditional = !((???*0* | ???*2* | ???*3* | ???*4*)) - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] @@ -10855,11 +14409,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -1947 -> 1948 free var = FreeVar(Error) +2483 -> 2484 free var = FreeVar(Error) -1947 -> 1949 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(169) +2483 -> 2485 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(169) -1947 -> 1950 call = ???*0*( +2483 -> 2486 call = ???*0*( `Minified React error #${169}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -10868,11 +14422,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${169}` ⚠️ nested operation -0 -> 1951 conditional = ???*0* +0 -> 2487 conditional = ???*0* - *0* arguments[2] ⚠️ function calls are not analysed yet -1951 -> 1952 call = (...) => (c | A({}, c, d))((???*0* | {} | ???*1* | ???*2*), ???*5*, ({} | ???*6*)) +2487 -> 2488 call = (...) => (c | A({}, c, d))((???*0* | {} | ???*1* | ???*2*), ???*5*, ({} | ???*6*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unknown mutation @@ -10891,11 +14445,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* unknown mutation ⚠️ This value might have side effects -1951 -> 1954 call = (...) => undefined({"current": false}) +2487 -> 2490 call = (...) => undefined({"current": false}) -1951 -> 1955 call = (...) => undefined({"current": {}}) +2487 -> 2491 call = (...) => undefined({"current": {}}) -1951 -> 1956 call = (...) => undefined({"current": {}}, (???*0* | {} | ???*1* | ???*2*)) +2487 -> 2492 call = (...) => undefined({"current": {}}, (???*0* | {} | ???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unknown mutation @@ -10910,13 +14464,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -1951 -> 1957 call = (...) => undefined({"current": false}) +2487 -> 2493 call = (...) => undefined({"current": false}) -0 -> 1958 call = (...) => undefined({"current": false}, ???*0*) +0 -> 2494 call = (...) => undefined({"current": false}, ???*0*) - *0* arguments[2] ⚠️ function calls are not analysed yet -0 -> 1959 conditional = (null === (null | [???*0*] | ???*1*)) +0 -> 2495 conditional = (null === (null | [???*0*] | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["slice"]((a + 1)) @@ -10924,7 +14478,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* eg ⚠️ circular variable reference -1959 -> 1961 member call = (null | [???*0*] | ???*1*)["push"](???*3*) +2495 -> 2497 member call = (null | [???*0*] | ???*1*)["push"](???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["slice"]((a + 1)) @@ -10934,11 +14488,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1962 call = (...) => undefined(???*0*) +0 -> 2498 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1963 conditional = (!((false | true)) | (null !== (null | [???*0*] | ???*1*))) +0 -> 2499 conditional = (!((false | true)) | (null !== (null | [???*0*] | ???*1*))) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["slice"]((a + 1)) @@ -10946,7 +14500,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* eg ⚠️ circular variable reference -1963 -> 1966 call = (null[(0 | ???*0*)] | ???*1* | ???*2* | ???*3* | ???*5* | ???*9*)(true) +2499 -> 2502 call = (null[(0 | ???*0*)] | ???*1* | ???*2* | ???*3* | ???*5* | ???*9*)(true) - *0* updated with update expression ⚠️ This value might have side effects - *1* arguments[0] @@ -10971,7 +14525,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* d ⚠️ circular variable reference -1963 -> 1968 member call = (null | [???*0*] | ???*1*)["slice"](((0 | ???*3*) + 1)) +2499 -> 2504 member call = (null | [???*0*] | ???*1*)["slice"](((0 | ???*3*) + 1)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["slice"]((a + 1)) @@ -10981,12 +14535,16 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* updated with update expression ⚠️ This value might have side effects -1963 -> 1969 call = module["unstable_scheduleCallback"]( +2499 -> 2505 call = module["unstable_scheduleCallback"]( module["unstable_ImmediatePriority"], (...) => null ) -0 -> 1975 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) +0 -> 2506 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2512 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -11006,7 +14564,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* max number of linking steps reached ⚠️ This value might have side effects -0 -> 1976 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) +0 -> 2513 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -11026,11 +14584,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1978 member call = ???*0*["toString"](32) +0 -> 2515 member call = ???*0*["toString"](32) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 1979 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) +0 -> 2516 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -11050,19 +14608,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[1] ⚠️ function calls are not analysed yet -0 -> 1981 call = (...) => undefined(???*0*, 1) +0 -> 2518 call = (...) => undefined(???*0*, 1) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1982 call = (...) => undefined(???*0*, 1, 0) +0 -> 2519 call = (...) => undefined(???*0*, 1, 0) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 1993 call = (...) => ???*0*(5, null, null, 0) +0 -> 2530 call = (...) => ???*0*(5, null, null, 0) - *0* unknown new expression ⚠️ This value might have side effects -0 -> 1998 conditional = (null === (???*0* | ???*1*)) +0 -> 2535 conditional = (null === (???*0* | ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["deletions"] @@ -11070,7 +14628,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -1998 -> 2002 member call = (???*0* | ???*1*)["push"](???*3*) +2535 -> 2539 member call = (???*0* | ???*1*)["push"](???*3*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["deletions"] @@ -11080,57 +14638,77 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unknown new expression ⚠️ This value might have side effects -0 -> 2007 member call = ???*0*["toLowerCase"]() +0 -> 2544 member call = ???*0*["toLowerCase"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2010 member call = ???*0*["toLowerCase"]() +0 -> 2547 member call = ???*0*["toLowerCase"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2011 conditional = ???*0* +0 -> 2548 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2012 conditional = ???*0* +0 -> 2549 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2012 -> 2015 call = (...) => (null | a)(???*0*) +2549 -> 2552 call = (...) => (null | a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2018 conditional = ???*0* +0 -> 2553 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2556 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2019 conditional = ???*0* +0 -> 2557 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2022 conditional = ???*0* +0 -> 2559 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2561 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2023 conditional = ???*0* +0 -> 2562 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2023 -> 2024 conditional = ???*0* +2562 -> 2563 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2023 -> 2026 call = (...) => ???*0*(18, null, null, 0) +2562 -> 2565 call = (...) => ???*0*(18, null, null, 0) - *0* unknown new expression ⚠️ This value might have side effects -0 -> 2032 conditional = (false | true) +0 -> 2569 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -2032 -> 2033 conditional = ???*0* +0 -> 2570 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2573 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2574 conditional = (false | true) + +2574 -> 2575 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2033 -> 2034 call = (...) => (undefined | ((null !== b) ? ???*0* : !(1)) | ???*1* | !(1))(???*3*, ???*4*) +2575 -> 2576 call = (...) => (undefined | ((null !== b) ? ???*0* : !(1)) | ???*1* | !(1))(???*3*, ???*4*) - *0* !(0) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -11145,11 +14723,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -2033 -> 2035 conditional = ???*0* +2575 -> 2577 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2035 -> 2036 call = (...) => ((0 !== ???*0*) && (0 === ???*1*))(???*2*) +2577 -> 2578 call = (...) => ((0 !== ???*0*) && (0 === ???*1*))(???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -11157,17 +14735,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -2035 -> 2037 conditional = ((0 !== ???*0*) | (0 === ???*1*)) +2577 -> 2579 conditional = ((0 !== ???*0*) | (0 === ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -2037 -> 2038 free var = FreeVar(Error) +2579 -> 2580 free var = FreeVar(Error) -2037 -> 2039 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(418) +2579 -> 2581 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(418) -2037 -> 2040 call = ???*0*( +2579 -> 2582 call = ???*0*( `Minified React error #${418}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -11176,11 +14754,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${418}` ⚠️ nested operation -2035 -> 2042 call = (...) => (null | a)(???*0*) +2577 -> 2584 call = (...) => (null | a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -2035 -> 2043 call = (...) => (undefined | ((null !== b) ? ???*0* : !(1)) | ???*1* | !(1))(???*3*, ???*4*) +2577 -> 2585 call = (...) => (undefined | ((null !== b) ? ???*0* : !(1)) | ???*1* | !(1))(???*3*, ???*4*) - *0* !(0) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -11195,17 +14773,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -2035 -> 2044 conditional = ???*0* +2577 -> 2586 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2044 -> 2045 call = (...) => undefined(???*0*, ???*1*) +2586 -> 2587 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2033 -> 2048 call = (...) => ((0 !== ???*0*) && (0 === ???*1*))(???*2*) +2575 -> 2590 call = (...) => ((0 !== ???*0*) && (0 === ???*1*))(???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -11213,17 +14791,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -2033 -> 2049 conditional = ((0 !== ???*0*) | (0 === ???*1*)) +2575 -> 2591 conditional = ((0 !== ???*0*) | (0 === ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -2049 -> 2050 free var = FreeVar(Error) +2591 -> 2592 free var = FreeVar(Error) -2049 -> 2051 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(418) +2591 -> 2593 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(418) -2049 -> 2052 call = ???*0*( +2591 -> 2594 call = ???*0*( `Minified React error #${418}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -11232,9 +14810,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${418}` ⚠️ nested operation -0 -> 2060 conditional = !((false | true)) +0 -> 2602 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -2060 -> 2061 call = (...) => undefined((???*0* | ???*1* | (???*3* ? ???*5* : null))) +2602 -> 2603 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2602 -> 2604 conditional = !((false | true)) + +2604 -> 2605 call = (...) => undefined((???*0* | ???*1* | (???*3* ? ???*5* : null))) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["memoizedState"] @@ -11250,7 +14836,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -0 -> 2067 call = (...) => ( +2604 -> 2606 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2604 -> 2612 call = (...) => ( || ("textarea" === a) || ("noscript" === a) || ("string" === typeof(b["children"])) @@ -11289,11 +14879,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* a ⚠️ circular variable reference -0 -> 2068 conditional = ???*0* +2604 -> 2613 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2068 -> 2069 call = (...) => ((0 !== ???*0*) && (0 === ???*1*))((???*2* | ???*3* | (???*5* ? ???*7* : null))) +2613 -> 2614 call = (...) => ((0 !== ???*0*) && (0 === ???*1*))((???*2* | ???*3* | (???*5* ? ???*7* : null))) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -11313,19 +14903,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* a ⚠️ circular variable reference -2068 -> 2070 conditional = ((0 !== ???*0*) | (0 === ???*1*)) +2613 -> 2615 conditional = ((0 !== ???*0*) | (0 === ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -2070 -> 2071 call = (...) => undefined() +2615 -> 2616 call = (...) => undefined() -2070 -> 2072 free var = FreeVar(Error) +2615 -> 2617 free var = FreeVar(Error) -2070 -> 2073 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(418) +2615 -> 2618 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(418) -2070 -> 2074 call = ???*0*( +2615 -> 2619 call = ???*0*( `Minified React error #${418}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -11334,7 +14924,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${418}` ⚠️ nested operation -2068 -> 2075 call = (...) => undefined((???*0* | ???*1* | (???*3* ? ???*5* : null)), ???*7*) +2613 -> 2620 call = (...) => undefined((???*0* | ???*1* | (???*3* ? ???*5* : null)), ???*7*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["memoizedState"] @@ -11352,11 +14942,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* max number of linking steps reached ⚠️ This value might have side effects -2068 -> 2077 call = (...) => (null | a)(???*0*) +2613 -> 2622 call = (...) => (null | a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2078 call = (...) => undefined((???*0* | ???*1* | (???*3* ? ???*5* : null))) +2604 -> 2623 call = (...) => undefined((???*0* | ???*1* | (???*3* ? ???*5* : null))) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["memoizedState"] @@ -11372,13 +14962,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -0 -> 2080 conditional = (13 === ???*0*) +2604 -> 2625 conditional = (13 === ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -2080 -> 2082 conditional = (null !== (???*0* | ???*1* | ???*3*)) +2625 -> 2627 conditional = (null !== (???*0* | ???*1* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["memoizedState"] @@ -11396,7 +14986,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* a ⚠️ circular variable reference -2080 -> 2084 conditional = !((???*0* | ???*1* | ???*3*)) +2625 -> 2629 conditional = !((???*0* | ???*1* | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["memoizedState"] @@ -11414,11 +15004,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* a ⚠️ circular variable reference -2084 -> 2085 free var = FreeVar(Error) +2629 -> 2630 free var = FreeVar(Error) -2084 -> 2086 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(317) +2629 -> 2631 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(317) -2084 -> 2087 call = ???*0*( +2629 -> 2632 call = ???*0*( `Minified React error #${317}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -11427,23 +15017,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${317}` ⚠️ nested operation -2080 -> 2090 conditional = (8 === ???*0*) +2625 -> 2635 conditional = (8 === ???*0*) - *0* ???*1*["nodeType"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -2090 -> 2092 conditional = ("/$" === ???*0*) +2635 -> 2637 conditional = ("/$" === ???*0*) - *0* ???*1*["data"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -2092 -> 2093 conditional = ???*0* +2637 -> 2638 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2093 -> 2095 call = (...) => (null | a)((???*0* | (???*2* ? ???*4* : null)["nextSibling"])) +2638 -> 2640 call = (...) => (null | a)((???*0* | (???*2* ? ???*4* : null)["nextSibling"])) - *0* ???*1*["nextSibling"] ⚠️ unknown object - *1* arguments[0] @@ -11457,11 +15047,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* a ⚠️ circular variable reference -2080 -> 2097 conditional = ???*0* +2625 -> 2642 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2097 -> 2100 call = (...) => (null | a)( +2642 -> 2645 call = (...) => (null | a)( ( | ???*0* | (???*3* ? ???*5* : null)["stateNode"]["nextSibling"] @@ -11482,21 +15072,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -0 -> 2102 call = (...) => (null | a)(???*0*) +2604 -> 2646 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2648 call = (...) => (null | a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2103 conditional = (null === (null | [???*0*])) +0 -> 2649 conditional = (null === (null | [???*0*])) - *0* arguments[0] ⚠️ function calls are not analysed yet -2103 -> 2105 member call = (null | [???*0*])["push"](???*1*) +2649 -> 2651 member call = (null | [???*0*])["push"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2108 conditional = (???*0* | ???*1*) +0 -> 2654 conditional = (???*0* | ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["defaultProps"] @@ -11504,7 +15098,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* a ⚠️ circular variable reference -2108 -> 2109 call = ???*0*({}, (???*2* | ???*3*)) +2654 -> 2655 call = ???*0*({}, (???*2* | ???*3*)) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -11523,17 +15117,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 2114 call = (...) => {"current": a}(null) +2654 -> 2660 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2654 -> 2661 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 2116 call = (...) => undefined({"current": null}) +0 -> 2662 call = (...) => {"current": a}(null) -0 -> 2120 conditional = (???*0* !== ???*1*) +0 -> 2664 call = (...) => undefined({"current": null}) + +0 -> 2668 conditional = (???*0* !== ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2131 conditional = ((null | ???*0*) !== ( +0 -> 2679 conditional = ((null | ???*0*) !== ( | ???*1* | {"context": ???*2*, "memoizedValue": ???*3*, "next": null} )) @@ -11548,7 +15150,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* a ⚠️ circular variable reference -2131 -> 2132 conditional = (null === (null | ???*0* | ???*1*)) +2679 -> 2680 conditional = (null === (null | ???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["dependencies"] @@ -11556,11 +15158,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* a ⚠️ circular variable reference -2132 -> 2133 free var = FreeVar(Error) +2680 -> 2681 free var = FreeVar(Error) -2132 -> 2134 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(308) +2680 -> 2682 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(308) -2132 -> 2135 call = ???*0*( +2680 -> 2683 call = ???*0*( `Minified React error #${308}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -11569,33 +15171,41 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${308}` ⚠️ nested operation -0 -> 2138 conditional = (null === (null | [???*0*])) +0 -> 2686 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2687 conditional = (null === (null | [???*0*])) - *0* arguments[0] ⚠️ function calls are not analysed yet -2138 -> 2140 member call = (null | [???*0*])["push"](???*1*) +2687 -> 2689 member call = (null | [???*0*])["push"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2142 conditional = (null === ???*0*) +0 -> 2691 conditional = (null === ???*0*) - *0* ???*1*["interleaved"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -2142 -> 2144 call = (...) => undefined(???*0*) +2691 -> 2693 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2149 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) +0 -> 2698 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2159 conditional = (3 === ???*0*) +0 -> 2699 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2709 conditional = (3 === ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* ???*2*["alternate"] @@ -11603,11 +15213,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2173 conditional = (0 !== ???*0*) +0 -> 2711 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2722 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2724 conditional = (null === ???*0*) +- *0* ???*1*["updateQueue"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +2724 -> 2725 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2724 -> 2727 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -2173 -> 2175 conditional = (null === ???*0*) +2727 -> 2729 conditional = (null === ???*0*) - *0* ???*1*["pending"] ⚠️ unknown object - *1* ???*2*["updateQueue"] @@ -11615,13 +15243,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -2173 -> 2181 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) +2727 -> 2735 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2183 conditional = (null === ???*0*) +2727 -> 2736 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2727 -> 2738 conditional = (null === ???*0*) - *0* ???*1*["pending"] ⚠️ unknown object - *1* ???*2*["updateQueue"] @@ -11629,19 +15261,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -2183 -> 2185 call = (...) => undefined(???*0*) +2738 -> 2740 call = (...) => undefined(???*0*) - *0* ???*1*["updateQueue"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2190 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) +2727 -> 2745 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2193 conditional = ((null !== (???*0* | ???*1*)) | ???*3*) +2727 -> 2746 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2749 conditional = ((null !== (???*0* | ???*1*)) | ???*3*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["updateQueue"] @@ -11654,7 +15290,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -2193 -> 2197 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +2749 -> 2753 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -11662,7 +15298,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported assign operation ⚠️ This value might have side effects -0 -> 2201 conditional = ( +0 -> 2757 conditional = ( | (null !== (???*0* | null["alternate"] | ???*2* | ???*3* | ???*4*)) | ???*6* ) @@ -11684,7 +15320,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -2201 -> 2203 conditional = (null !== ( +2757 -> 2759 conditional = (null !== ( | ???*0* | { "baseState": ???*2*, @@ -11755,15 +15391,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *23* arguments[0] ⚠️ function calls are not analysed yet -2203 -> 2209 conditional = ???*0* +2759 -> 2765 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2203 -> 2212 conditional = ???*0* +2759 -> 2768 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2219 conditional = (null === ( +2757 -> 2774 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2757 -> 2776 conditional = (null === ( | ???*0* | ???*1* | null @@ -11811,27 +15451,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* unknown mutation ⚠️ This value might have side effects -0 -> 2228 conditional = ???*0* +0 -> 2785 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2228 -> 2233 conditional = ???*0* +2785 -> 2790 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2228 -> 2238 conditional = ???*0* +2785 -> 2795 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2242 conditional = ???*0* +0 -> 2799 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2242 -> 2246 conditional = ???*0* +2799 -> 2803 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2246 -> 2253 conditional = ("function" === ???*0*) +2803 -> 2810 conditional = ("function" === ???*0*) - *0* typeof((???*1* | ???*2* | ???*6* | null["next"]["payload"])) ⚠️ nested operation - *1* arguments[0] @@ -11853,7 +15493,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unsupported expression ⚠️ This value might have side effects -2253 -> 2255 member call = ( +2810 -> 2812 member call = ( | ???*0* | ???*1* | ???*6* @@ -11899,7 +15539,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* max number of linking steps reached ⚠️ This value might have side effects -2246 -> 2259 conditional = ("function" === ???*0*) +2803 -> 2816 conditional = ("function" === ???*0*) - *0* typeof((???*1* | ???*2* | ???*6* | null["next"]["payload"])) ⚠️ nested operation - *1* arguments[0] @@ -11921,7 +15561,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unsupported expression ⚠️ This value might have side effects -2259 -> 2261 member call = ( +2816 -> 2818 member call = ( | ???*0* | ???*1* | ???*6* @@ -11967,7 +15607,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* max number of linking steps reached ⚠️ This value might have side effects -2246 -> 2262 call = ???*0*({}, ???*2*, ???*3*) +2803 -> 2819 call = ???*0*({}, ???*2*, ???*3*) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -11979,25 +15619,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -2246 -> 2267 conditional = ???*0* +2803 -> 2824 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2267 -> 2270 member call = ???*0*["push"](???*1*) +2824 -> 2827 member call = ???*0*["push"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2246 -> 2274 conditional = ???*0* +2803 -> 2831 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2242 -> 2277 conditional = ???*0* +2799 -> 2834 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2242 -> 2290 conditional = (null !== (???*0* | ???*1*)) +2799 -> 2847 conditional = (null !== (???*0* | ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["interleaved"] @@ -12009,7 +15649,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2299 conditional = (null !== (???*0* | ???*1* | 0["effects"] | ???*3*)) +0 -> 2856 conditional = (null !== (???*0* | ???*1* | 0["effects"] | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["effects"] @@ -12022,7 +15662,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -2299 -> 2303 conditional = (null !== (???*0* | 0["effects"][(???*5* | 0 | ???*6*)]["callback"] | ???*7*)) +2856 -> 2860 conditional = (null !== (???*0* | 0["effects"][(???*5* | 0 | ???*6*)]["callback"] | ???*7*)) - *0* ???*1*["callback"] ⚠️ unknown object ⚠️ This value might have side effects @@ -12044,7 +15684,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[2] ⚠️ function calls are not analysed yet -2303 -> 2305 conditional = ("function" !== ???*0*) +2860 -> 2862 conditional = ("function" !== ???*0*) - *0* typeof((???*1* | 0["effects"][(???*6* | 0 | ???*7*)]["callback"] | ???*8*)) ⚠️ nested operation - *1* ???*2*["callback"] @@ -12068,9 +15708,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[2] ⚠️ function calls are not analysed yet -2305 -> 2306 free var = FreeVar(Error) +2862 -> 2863 free var = FreeVar(Error) -2305 -> 2307 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`( +2862 -> 2864 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`( 191, (???*0* | 0["effects"][(???*5* | 0 | ???*6*)]["callback"] | ???*7*) ) @@ -12095,7 +15735,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[2] ⚠️ function calls are not analysed yet -2305 -> 2308 call = ???*0*( +2862 -> 2865 call = ???*0*( `Minified React error #${191}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -12104,7 +15744,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${191}` ⚠️ nested operation -2303 -> 2310 member call = (???*0* | 0["effects"][(???*5* | 0 | ???*6*)]["callback"] | ???*7*)["call"]( +2860 -> 2867 member call = (???*0* | 0["effects"][(???*5* | 0 | ???*6*)]["callback"] | ???*7*)["call"]( (???*9* | 0["effects"][(???*13* | 0 | ???*14*)] | ???*15*) ) - *0* ???*1*["callback"] @@ -12143,7 +15783,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2314 call = (???*0* | ???*1* | (???*3* ? (???*5* | ???*6*) : ???*8*))(???*11*, (???*12* | ???*13*)) +0 -> 2871 call = (???*0* | ???*1* | (???*3* ? (???*5* | ???*6*) : ???*8*))(???*11*, (???*12* | ???*13*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*(d, b) @@ -12178,7 +15818,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2315 conditional = ((null === (???*0* | ???*1* | ???*3*)) | (???*12* === (???*13* | ???*14* | ???*16*))) +0 -> 2872 conditional = ((null === (???*0* | ???*1* | ???*3*)) | (???*12* === (???*13* | ???*14* | ???*16*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*(d, b) @@ -12236,7 +15876,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2315 -> 2316 call = ???*0*( +2872 -> 2873 call = ???*0*( {}, (???*2* | ???*3*), (???*5* | ???*6* | (???*8* ? (???*10* | ???*11*) : ???*13*)) @@ -12279,7 +15919,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 2322 call = (...) => ((3 === b["tag"]) ? c : null)((???*0* | ???*1*)) +0 -> 2879 call = (...) => ((3 === b["tag"]) ? c : null)((???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["_reactInternals"] @@ -12287,7 +15927,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* a ⚠️ circular variable reference -0 -> 2324 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +0 -> 2880 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2882 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -12295,7 +15939,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 2325 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3*)) +0 -> 2883 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* Ck @@ -12308,7 +15952,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* a ⚠️ circular variable reference -0 -> 2326 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( +0 -> 2884 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( (???*0* ? ???*2* : ???*3*), ( | 1 @@ -12403,7 +16047,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* a ⚠️ circular variable reference -0 -> 2329 call = (...) => (null | Zg(a, c))( +0 -> 2887 call = (...) => (null | Zg(a, c))( (???*0* | ???*1*), { "eventTime": (???*3* ? ???*5* : ???*6*), @@ -12580,7 +16224,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *65* a ⚠️ circular variable reference -0 -> 2330 call = (...) => undefined( +0 -> 2888 call = (...) => undefined( (???*0* | null | (???*1* ? ???*5* : null)), (???*8* | ???*9*), ( @@ -12699,7 +16343,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *47* unsupported expression ⚠️ This value might have side effects -0 -> 2331 call = (...) => undefined( +0 -> 2889 call = (...) => undefined( (???*0* | null | (???*1* ? ???*5* : null)), (???*8* | ???*9*), ( @@ -12795,7 +16439,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* a ⚠️ circular variable reference -0 -> 2333 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +0 -> 2891 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -12803,7 +16447,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 2334 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3*)) +0 -> 2892 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* Ck @@ -12816,7 +16460,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* a ⚠️ circular variable reference -0 -> 2335 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( +0 -> 2893 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( (???*0* ? ???*2* : ???*3*), ( | 1 @@ -12911,7 +16555,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* a ⚠️ circular variable reference -0 -> 2339 call = (...) => (null | Zg(a, c))( +0 -> 2897 call = (...) => (null | Zg(a, c))( (???*0* | ???*1*), { "eventTime": (???*3* ? ???*5* : ???*6*), @@ -13088,7 +16732,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *65* a ⚠️ circular variable reference -0 -> 2340 call = (...) => undefined( +0 -> 2898 call = (...) => undefined( (???*0* | null | (???*1* ? ???*5* : null)), (???*8* | ???*9*), ( @@ -13207,7 +16851,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *47* unsupported expression ⚠️ This value might have side effects -0 -> 2341 call = (...) => undefined( +0 -> 2899 call = (...) => undefined( (???*0* | null | (???*1* ? ???*5* : null)), (???*8* | ???*9*), ( @@ -13303,7 +16947,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* a ⚠️ circular variable reference -0 -> 2343 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +0 -> 2901 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -13311,7 +16955,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 2344 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3*)) +0 -> 2902 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* Ck @@ -13324,7 +16968,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* a ⚠️ circular variable reference -0 -> 2345 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( +0 -> 2903 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( (???*0* ? ???*2* : ???*3*), ( | 1 @@ -13419,7 +17063,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* a ⚠️ circular variable reference -0 -> 2348 call = (...) => (null | Zg(a, c))( +0 -> 2906 call = (...) => (null | Zg(a, c))( (???*0* | ???*1*), { "eventTime": (???*3* ? ???*5* : ???*6*), @@ -13596,7 +17240,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *65* a ⚠️ circular variable reference -0 -> 2349 call = (...) => undefined( +0 -> 2907 call = (...) => undefined( (???*0* | null | (???*1* ? ???*5* : null)), (???*8* | ???*9*), ( @@ -13715,7 +17359,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *47* unsupported expression ⚠️ This value might have side effects -0 -> 2350 call = (...) => undefined( +0 -> 2908 call = (...) => undefined( (???*0* | null | (???*1* ? ???*5* : null)), (???*8* | ???*9*), ( @@ -13811,7 +17455,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* a ⚠️ circular variable reference -0 -> 2353 conditional = ("function" === ???*0*) +0 -> 2911 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* ???*2*["shouldComponentUpdate"] @@ -13819,7 +17463,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -2353 -> 2355 member call = (???*0* | ???*1*)["shouldComponentUpdate"](???*3*, ???*4*, ???*5*) +2911 -> 2913 member call = (???*0* | ???*1*)["shouldComponentUpdate"](???*3*, ???*4*, ???*5*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -13833,25 +17477,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[6] ⚠️ function calls are not analysed yet -2353 -> 2359 conditional = ???*0* +2911 -> 2917 conditional = ???*0* - *0* ???*1*["prototype"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -2359 -> 2360 call = (...) => (!(0) | !(1))(???*0*, ???*1*) +2917 -> 2918 call = (...) => (!(0) | !(1))(???*0*, ???*1*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[3] ⚠️ function calls are not analysed yet -2359 -> 2361 call = (...) => (!(0) | !(1))(???*0*, ???*1*) +2917 -> 2919 call = (...) => (!(0) | !(1))(???*0*, ???*1*) - *0* arguments[4] ⚠️ function calls are not analysed yet - *1* arguments[5] ⚠️ function calls are not analysed yet -0 -> 2363 conditional = ( +0 -> 2920 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2922 conditional = ( | ("object" === ???*0*) | (null !== (???*12* | ???*14* | ???*16* | ???*17* | ???*18*)) ) @@ -13906,7 +17554,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *22* arguments[0] ⚠️ function calls are not analysed yet -2363 -> 2364 call = (...) => b( +2922 -> 2923 call = (...) => b( (???*0* | ???*2* | ???*4* | ???*5* | (???*6* ? ({} | ???*7*) : {})) ) - *0* ???*1*["contextType"] @@ -13932,7 +17580,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[0] ⚠️ function calls are not analysed yet -2363 -> 2365 call = (...) => ((null !== a) && (???*0* !== a))((???*1* | ???*2*)) +2922 -> 2924 call = (...) => ((null !== a) && (???*0* !== a))((???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -13940,7 +17588,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unknown new expression ⚠️ This value might have side effects -2363 -> 2366 conditional = ((null !== (???*0* | ???*1* | ???*2*)) | (???*4* !== (???*5* | ???*6* | ???*7*))) +2922 -> 2925 conditional = ((null !== (???*0* | ???*1* | ???*2*)) | (???*4* !== (???*5* | ???*6* | ???*7*))) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -13960,7 +17608,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* a ⚠️ circular variable reference -2363 -> 2369 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)((???*0* | ???*1*), ({} | (???*3* ? ({} | ???*8*) : ({} | ???*9*)))) +2922 -> 2928 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)((???*0* | ???*1*), ({} | (???*3* ? ({} | ???*8*) : ({} | ???*9*)))) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -13982,7 +17630,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* unknown mutation ⚠️ This value might have side effects -0 -> 2373 conditional = ((null !== (???*0* | ???*2*)) | (???*4* !== (???*5* | ???*7*))) +0 -> 2932 conditional = ((null !== (???*0* | ???*2*)) | (???*4* !== (???*5* | ???*7*))) - *0* ???*1*["state"] ⚠️ unknown object - *1* arguments[1] @@ -14004,7 +17652,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unknown new expression ⚠️ This value might have side effects -0 -> 2384 member call = ???*0*["componentWillReceiveProps"](???*1*, ???*2*) +0 -> 2940 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 2944 member call = ???*0*["componentWillReceiveProps"](???*1*, ???*2*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -14012,7 +17664,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2387 member call = ???*0*["UNSAFE_componentWillReceiveProps"](???*1*, ???*2*) +0 -> 2947 member call = ???*0*["UNSAFE_componentWillReceiveProps"](???*1*, ???*2*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -14020,7 +17672,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2391 member call = { +0 -> 2951 member call = { "isMounted": (...) => (???*0* ? (Vb(a) === a) : !(1)), "enqueueSetState": (...) => undefined, "enqueueReplaceState": (...) => undefined, @@ -14035,11 +17687,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2397 call = (...) => undefined(???*0*) +0 -> 2957 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2399 conditional = (("object" === ???*0*) | (null !== (???*10* | ???*12*))) +0 -> 2959 conditional = (("object" === ???*0*) | (null !== (???*10* | ???*12*))) - *0* typeof((???*1* | ???*3*)) ⚠️ nested operation - *1* ???*2*["contextType"] @@ -14081,7 +17733,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* unknown mutation ⚠️ This value might have side effects -2399 -> 2401 call = (...) => b( +2959 -> 2961 call = (...) => b( (???*0* | (???*2* ? ({} | ???*7*) : ({} | ???*8*))) ) - *0* ???*1*["contextType"] @@ -14103,7 +17755,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unknown mutation ⚠️ This value might have side effects -2399 -> 2402 call = (...) => ((null !== a) && (???*0* !== a))((???*1* | ???*2*)) +2959 -> 2962 call = (...) => ((null !== a) && (???*0* !== a))((???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -14115,7 +17767,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -2399 -> 2403 conditional = ((null !== (???*0* | ???*1*)) | (???*4* !== (???*5* | ???*6*))) +2959 -> 2963 conditional = ((null !== (???*0* | ???*1*)) | (???*4* !== (???*5* | ???*6*))) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["state"] @@ -14135,7 +17787,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[0] ⚠️ function calls are not analysed yet -2399 -> 2406 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)( +2959 -> 2966 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)( ???*0*, (???*1* | (???*3* ? ({} | ???*8*) : ({} | ???*9*))) ) @@ -14160,7 +17812,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* unknown mutation ⚠️ This value might have side effects -0 -> 2410 call = (...) => undefined( +0 -> 2970 call = (...) => undefined( ???*0*, (???*1* | ???*2*), (???*5* | (???*7* ? ({} | ???*12*) : ({} | ???*13*))), @@ -14197,19 +17849,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2420 member call = ???*0*["componentWillMount"]() +0 -> 2980 member call = ???*0*["componentWillMount"]() - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2423 member call = ???*0*["UNSAFE_componentWillMount"]() +0 -> 2983 member call = ???*0*["UNSAFE_componentWillMount"]() - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2427 member call = { +0 -> 2987 member call = { "isMounted": (...) => (???*0* ? (Vb(a) === a) : !(1)), "enqueueSetState": (...) => undefined, "enqueueReplaceState": (...) => undefined, @@ -14228,7 +17880,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2428 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) +0 -> 2988 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -14240,7 +17892,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2434 conditional = ((null !== (???*0* | ???*1*)) | ("function" !== ???*3*) | ("object" !== ???*7*)) +0 -> 2994 conditional = ((null !== (???*0* | ???*1*)) | ("function" !== ???*3*) | ("object" !== ???*7*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["ref"] @@ -14264,13 +17916,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[2] ⚠️ function calls are not analysed yet -2434 -> 2436 conditional = ???*0* +2994 -> 2996 conditional = ???*0* - *0* ???*1*["_owner"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -2436 -> 2438 conditional = (???*0* | ???*1*) +2996 -> 2998 conditional = (???*0* | ???*1*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["_owner"] @@ -14278,17 +17930,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* c ⚠️ circular variable reference -2438 -> 2440 conditional = (1 !== ???*0*) +2998 -> 3000 conditional = (1 !== ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -2440 -> 2441 free var = FreeVar(Error) +3000 -> 3001 free var = FreeVar(Error) -2440 -> 2442 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(309) +3000 -> 3002 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(309) -2440 -> 2443 call = ???*0*( +3000 -> 3003 call = ???*0*( `Minified React error #${309}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -14297,15 +17949,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${309}` ⚠️ nested operation -2436 -> 2445 conditional = !(???*0*) +2996 -> 3005 conditional = !(???*0*) - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -2445 -> 2446 free var = FreeVar(Error) +3005 -> 3006 free var = FreeVar(Error) -2445 -> 2447 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(147, (???*0* | ???*1*)) +3005 -> 3007 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(147, (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["ref"] @@ -14313,7 +17965,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2445 -> 2448 call = ???*0*( +3005 -> 3008 call = ???*0*( `Minified React error #${147}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -14322,7 +17974,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${147}` ⚠️ nested operation -2436 -> 2453 conditional = ( +2996 -> 3013 conditional = ( | (null !== (???*0* | (...) => undefined)) | (null !== (???*1* | (...) => undefined["ref"])) | ("function" === ???*3*) @@ -14353,11 +18005,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* arguments[2] ⚠️ function calls are not analysed yet -2436 -> 2457 conditional = (null === ???*0*) +3013 -> 3015 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3013 -> 3018 conditional = (null === ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -2434 -> 2461 conditional = ("string" !== ???*0*) +3013 -> 3022 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +2996 -> 3023 conditional = ("string" !== ???*0*) - *0* typeof((???*1* | ???*2*)) ⚠️ nested operation - *1* arguments[0] @@ -14367,11 +18027,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -2461 -> 2462 free var = FreeVar(Error) +3023 -> 3024 free var = FreeVar(Error) -2461 -> 2463 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(284) +3023 -> 3025 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(284) -2461 -> 2464 call = ???*0*( +3023 -> 3026 call = ???*0*( `Minified React error #${284}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -14380,15 +18040,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${284}` ⚠️ nested operation -2434 -> 2466 conditional = !(???*0*) +2996 -> 3028 conditional = !(???*0*) - *0* ???*1*["_owner"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -2466 -> 2467 free var = FreeVar(Error) +3028 -> 3029 free var = FreeVar(Error) -2466 -> 2468 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(290, (???*0* | ???*1*)) +3028 -> 3030 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(290, (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["ref"] @@ -14396,7 +18056,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2466 -> 2469 call = ???*0*( +3028 -> 3031 call = ???*0*( `Minified React error #${290}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -14405,9 +18065,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${290}` ⚠️ nested operation -0 -> 2473 free var = FreeVar(Object) +0 -> 3032 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 2474 member call = ???*0*["call"](???*3*) +0 -> 3036 free var = FreeVar(Object) + +0 -> 3037 member call = ???*0*["call"](???*3*) - *0* ???*1*["toString"] ⚠️ unknown object ⚠️ This value might have side effects @@ -14420,9 +18084,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2475 free var = FreeVar(Error) +0 -> 3038 free var = FreeVar(Error) -0 -> 2476 conditional = ("[object Object]" === (???*0* | ???*1*)) +0 -> 3039 conditional = ("[object Object]" === (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["call"](b) @@ -14438,16 +18102,16 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2476 -> 2479 free var = FreeVar(Object) +3039 -> 3042 free var = FreeVar(Object) -2476 -> 2480 member call = ???*0*["keys"](???*1*) +3039 -> 3043 member call = ???*0*["keys"](???*1*) - *0* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects - *1* arguments[1] ⚠️ function calls are not analysed yet -2476 -> 2481 member call = ???*0*["join"](", ") +3039 -> 3044 member call = ???*0*["join"](", ") - *0* ???*1*["keys"](b) ⚠️ unknown callee object ⚠️ This value might have side effects @@ -14455,7 +18119,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 2482 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(31, (???*0* ? ???*6* : (???*10* | ???*11*))) +0 -> 3045 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(31, (???*0* ? ???*6* : (???*10* | ???*11*))) - *0* ("[object Object]" === (???*1* | ???*2*)) ⚠️ nested operation - *1* arguments[0] @@ -14498,7 +18162,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -0 -> 2483 call = ???*0*( +0 -> 3046 call = ???*0*( `Minified React error #${31}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -14507,7 +18171,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${31}` ⚠️ nested operation -0 -> 2486 call = ???*0*(???*2*) +0 -> 3049 call = ???*0*(???*2*) - *0* ???*1*["_init"] ⚠️ unknown object - *1* arguments[0] @@ -14517,17 +18181,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2487 conditional = ???*0* +0 -> 3050 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3051 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3052 conditional = ???*0* - *0* arguments[0] ⚠️ function calls are not analysed yet -2487 -> 2489 conditional = (null === ???*0*) +3052 -> 3054 conditional = (null === ???*0*) - *0* ???*1*["deletions"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -2489 -> 2493 member call = ???*0*["push"](???*2*) +3054 -> 3058 member call = ???*0*["push"](???*2*) - *0* ???*1*["deletions"] ⚠️ unknown object - *1* arguments[0] @@ -14535,7 +18207,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2494 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +0 -> 3059 conditional = !(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +3059 -> 3060 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3059 -> 3061 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -14545,15 +18225,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* d ⚠️ circular variable reference -0 -> 2496 free var = FreeVar(Map) +3059 -> 3063 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3064 free var = FreeVar(Map) -0 -> 2498 conditional = (null !== ???*0*) +0 -> 3066 conditional = (null !== ???*0*) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -2498 -> 2501 member call = (???*0* | ???*1*)["set"](???*2*, (???*4* | ???*5*)) +3066 -> 3069 member call = (???*0* | ???*1*)["set"](???*2*, (???*4* | ???*5*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -14569,7 +18253,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* b ⚠️ circular variable reference -2498 -> 2504 member call = (???*0* | ???*1*)["set"](???*2*, (???*4* | ???*5*)) +3066 -> 3072 member call = (???*0* | ???*1*)["set"](???*2*, (???*4* | ???*5*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -14585,7 +18269,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* b ⚠️ circular variable reference -0 -> 2506 call = (...) => c((???*0* | ???*1* | ???*3*), ???*4*) +0 -> 3074 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3075 call = (...) => c((???*0* | ???*1* | ???*3*), ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["alternate"] @@ -14597,11 +18285,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2510 conditional = !(???*0*) +0 -> 3078 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3080 conditional = !(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2513 conditional = (null !== (???*0* | ???*1*)) +3080 -> 3082 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3080 -> 3084 conditional = (null !== (???*0* | ???*1*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["alternate"] @@ -14609,7 +18305,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2520 conditional = ((null === (???*0* | ???*1* | ???*2* | ???*3*)) | (6 !== (???*5* | ???*7*))) +3084 -> 3087 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3084 -> 3089 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3092 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3094 conditional = ((null === (???*0* | ???*1* | ???*2* | ???*3*)) | (6 !== (???*5* | ???*7*))) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -14630,7 +18338,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unknown new expression ⚠️ This value might have side effects -2520 -> 2522 call = (...) => a(???*0*, ???*1*, ???*3*) +3094 -> 3096 call = (...) => a(???*0*, ???*1*, ???*3*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["mode"] @@ -14640,7 +18348,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2524 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*) +3094 -> 3098 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3094 -> 3099 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -14654,7 +18366,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2527 conditional = (???*0* === ???*2*) +3094 -> 3101 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3103 conditional = (???*0* === ???*2*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[2] @@ -14666,7 +18382,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2527 -> 2531 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, (???*6* | ???*7* | ???*9* | ???*10*), ???*11*) +3103 -> 3107 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, (???*6* | ???*7* | ???*9* | ???*10*), ???*11*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -14696,13 +18412,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2534 call = (...) => b(a["_payload"])(???*0*) +3103 -> 3108 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3103 -> 3111 call = (...) => b(a["_payload"])(???*0*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2536 conditional = ( +3103 -> 3113 conditional = ( | (null !== ???*0*) | (???*1* === ???*3*) | ("object" === ???*5*) @@ -14755,7 +18475,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *20* arguments[1] ⚠️ function calls are not analysed yet -2536 -> 2538 call = (...) => a(???*0*, ???*1*) +3113 -> 3115 call = (...) => a(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["props"] @@ -14763,7 +18483,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2536 -> 2540 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, ???*2*) +3113 -> 3117 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -14771,7 +18491,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2546 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)(???*1*, ???*3*, ???*5*, null, ???*7*, (???*9* | ???*10* | ???*12* | ???*13*)) +3113 -> 3119 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3113 -> 3124 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)(???*1*, ???*3*, ???*5*, null, ???*7*, (???*9* | ???*10* | ???*12* | ???*13*)) - *0* a ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -14803,7 +18527,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -0 -> 2548 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, ???*2*) +3113 -> 3126 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -14811,7 +18535,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2557 conditional = ( +3113 -> 3128 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3136 conditional = ( | (null === (???*0* | ???*1* | ???*3* | ???*4*)) | (4 !== (???*5* | ???*7*)) | ((???*9* | ???*12*) !== ???*15*) @@ -14854,7 +18582,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[2] ⚠️ function calls are not analysed yet -2557 -> 2559 call = (...) => b(???*0*, ???*1*, ???*3*) +3136 -> 3138 call = (...) => b(???*0*, ???*1*, ???*3*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["mode"] @@ -14864,7 +18592,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2562 call = (...) => a((???*0* | ???*1* | ???*3* | ???*4*), (???*5* | []){truthy}) +3136 -> 3140 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3136 -> 3142 call = (...) => a((???*0* | ???*1* | ???*3* | ???*4*), (???*5* | []){truthy}) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["mode"] @@ -14880,7 +18612,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2565 conditional = ((null === (???*0* | ???*1* | ???*2* | ???*3*)) | (7 !== (???*5* | ???*7*))) +3136 -> 3144 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3146 conditional = ((null === (???*0* | ???*1* | ???*2* | ???*3*)) | (7 !== (???*5* | ???*7*))) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -14901,7 +18637,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unknown new expression ⚠️ This value might have side effects -2565 -> 2567 call = (...) => a(???*0*, ???*1*, ???*3*, ???*4*) +3146 -> 3148 call = (...) => a(???*0*, ???*1*, ???*3*, ???*4*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["mode"] @@ -14913,7 +18649,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[4] ⚠️ function calls are not analysed yet -0 -> 2569 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*) +3146 -> 3150 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3146 -> 3151 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unknown new expression @@ -14927,11 +18667,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2571 conditional = ???*0* +3146 -> 3153 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3154 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2571 -> 2573 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*)) +3154 -> 3156 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* b @@ -14968,11 +18712,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -0 -> 2575 conditional = ???*0* +3154 -> 3158 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3154 -> 3159 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2575 -> 2581 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)( +3159 -> 3165 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)( (???*1* | ???*3*), (???*5* | ???*7*), (???*9* | ???*11*), @@ -15036,7 +18784,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -2575 -> 2583 call = (...) => (b["ref"] | b | a)(???*0*, null, (???*1* | ???*2* | ???*3* | ???*4*)) +3159 -> 3167 call = (...) => (b["ref"] | b | a)(???*0*, null, (???*1* | ???*2* | ???*3* | ???*4*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -15050,7 +18798,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -2575 -> 2586 call = (...) => b((???*0* | ???*1* | ???*2* | ???*3*), ???*5*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*)) +3159 -> 3169 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3159 -> 3171 call = (...) => b((???*0* | ???*1* | ???*2* | ???*3*), ???*5*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* b @@ -15087,7 +18839,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -2575 -> 2590 call = (???*0* | ???*2*)((???*4* | ???*6*)) +3159 -> 3173 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3159 -> 3176 call = (???*0* | ???*2*)((???*4* | ???*6*)) - *0* ???*1*["_init"] ⚠️ unknown object - *1* arguments[1] @@ -15107,7 +18863,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unknown new expression ⚠️ This value might have side effects -2575 -> 2591 call = (...) => (???*0* | q(a, d(b["_payload"]), c) | null)(???*1*, ???*2*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*)) +3159 -> 3177 call = (...) => (???*0* | q(a, d(b["_payload"]), c) | null)(???*1*, ???*2*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*)) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15146,7 +18902,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -2575 -> 2592 call = ???*0*((???*2* | ???*3* | ???*4* | ???*5*)) +3159 -> 3178 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3159 -> 3179 call = ???*0*((???*2* | ???*3* | ???*4* | ???*5*)) - *0* ???*1*["isArray"] ⚠️ unknown object ⚠️ This value might have side effects @@ -15164,7 +18924,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -2575 -> 2593 call = (...) => (null | (("function" === typeof(a)) ? a : null))((???*0* | ???*1* | ???*2* | ???*3*)) +3159 -> 3180 call = (...) => (null | (("function" === typeof(a)) ? a : null))((???*0* | ???*1* | ???*2* | ???*3*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* b @@ -15176,7 +18936,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -2575 -> 2594 conditional = ( +3159 -> 3181 conditional = ( | ???*0* | null | (???*3* ? (???*12* | ???*13* | ???*14* | ???*15* | ???*17*) : null) @@ -15227,7 +18987,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2594 -> 2596 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*), null) +3181 -> 3183 call = (...) => a((???*0* | ???*1* | ???*2* | ???*3*), ???*5*, (???*7* | ???*8* | ???*11* | ???*14* | ???*15*), null) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* b @@ -15264,7 +19024,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -2575 -> 2598 call = (...) => undefined(???*0*, (???*1* | ???*2* | ???*3* | ???*4*)) +3181 -> 3185 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3181 -> 3186 call = (...) => undefined(???*0*, (???*1* | ???*2* | ???*3* | ???*4*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -15278,11 +19042,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2599 conditional = (null !== ???*0*) +3154 -> 3187 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3188 conditional = (null !== ???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2601 conditional = (("string" === ???*0*) | ("" !== ???*2*) | ("number" === ???*3*)) +0 -> 3190 conditional = (("string" === ???*0*) | ("" !== ???*2*) | ("number" === ???*3*)) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[2] @@ -15294,7 +19062,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[2] ⚠️ function calls are not analysed yet -2601 -> 2602 conditional = (null !== (???*0* | ???*5*)) +3190 -> 3191 conditional = (null !== (???*0* | ???*5*)) - *0* (???*1* ? ???*3* : null) ⚠️ nested operation - *1* (null !== ???*2*) @@ -15310,7 +19078,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[2] ⚠️ function calls are not analysed yet -2602 -> 2603 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, ???*4*) +3191 -> 3192 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, ???*4*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15323,7 +19091,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2604 conditional = (("object" === ???*0*) | (null !== ???*2*)) +3190 -> 3193 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3190 -> 3194 conditional = (("object" === ???*0*) | (null !== ???*2*)) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[2] @@ -15331,7 +19103,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2604 -> 2607 conditional = (???*0* === (???*2* | ???*7*)) +3194 -> 3197 conditional = (???*0* === (???*2* | ???*7*)) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[2] @@ -15351,7 +19123,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[2] ⚠️ function calls are not analysed yet -2607 -> 2608 call = (...) => (m(a, b, c["props"]["children"], d, c["key"]) | ???*0* | d)(???*1*, ???*2*, ???*3*, ???*4*) +3197 -> 3198 call = (...) => (m(a, b, c["props"]["children"], d, c["key"]) | ???*0* | d)(???*1*, ???*2*, ???*3*, ???*4*) - *0* d ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15364,7 +19136,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -2604 -> 2610 conditional = (???*0* === (???*2* | ???*7*)) +3194 -> 3199 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3194 -> 3201 conditional = (???*0* === (???*2* | ???*7*)) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[2] @@ -15384,7 +19160,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[2] ⚠️ function calls are not analysed yet -2610 -> 2611 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, ???*4*) +3201 -> 3202 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, ???*4*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15397,7 +19173,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -2604 -> 2614 call = ((???*0* ? ???*2* : null) | ???*4*)(???*6*) +3194 -> 3203 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3194 -> 3206 call = ((???*0* ? ???*2* : null) | ???*4*)(???*6*) - *0* (null !== ???*1*) ⚠️ nested operation - *1* arguments[1] @@ -15415,7 +19195,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[2] ⚠️ function calls are not analysed yet -2604 -> 2615 call = (...) => ( +3194 -> 3207 call = (...) => ( | ((null !== e) ? null : h(a, b, `${c}`, d)) | ((c["key"] === e) ? k(a, b, c, d) : null) | ((c["key"] === e) ? l(a, b, c, d) : null) @@ -15447,7 +19227,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[3] ⚠️ function calls are not analysed yet -2604 -> 2616 call = ???*0*(???*2*) +3194 -> 3208 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3194 -> 3209 call = ???*0*(???*2*) - *0* ???*1*["isArray"] ⚠️ unknown object ⚠️ This value might have side effects @@ -15457,11 +19241,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2604 -> 2617 call = (...) => (null | (("function" === typeof(a)) ? a : null))(???*0*) +3194 -> 3210 call = (...) => (null | (("function" === typeof(a)) ? a : null))(???*0*) - *0* arguments[2] ⚠️ function calls are not analysed yet -2604 -> 2618 conditional = (???*0* | null | (???*3* ? (???*10* | ???*11* | ???*13*) : null)) +3194 -> 3211 conditional = (???*0* | null | (???*3* ? (???*10* | ???*11* | ???*13*) : null)) - *0* ???*1*(c) ⚠️ unknown callee ⚠️ This value might have side effects @@ -15500,7 +19284,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* a ⚠️ circular variable reference -2618 -> 2619 conditional = (null !== (???*0* | ???*5*)) +3211 -> 3212 conditional = (null !== (???*0* | ???*5*)) - *0* (???*1* ? ???*3* : null) ⚠️ nested operation - *1* (null !== ???*2*) @@ -15516,7 +19300,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[2] ⚠️ function calls are not analysed yet -2619 -> 2620 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, ???*4*, null) +3212 -> 3213 call = (...) => (???*0* | b)(???*1*, ???*2*, ???*3*, ???*4*, null) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15529,13 +19313,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -2604 -> 2621 call = (...) => undefined(???*0*, ???*1*) +3211 -> 3214 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3211 -> 3215 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 2622 conditional = (("string" === ???*0*) | ("" !== ???*2*) | ("number" === ???*3*)) +3190 -> 3216 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3217 conditional = (("string" === ???*0*) | ("" !== ???*2*) | ("number" === ???*3*)) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[3] @@ -15547,7 +19339,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -2622 -> 2624 member call = (???*0* | ???*1* | null)["get"](???*3*) +3217 -> 3219 member call = (???*0* | ???*1* | null)["get"](???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["get"](c) @@ -15557,7 +19349,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -2622 -> 2625 call = (...) => (???*0* | b)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*) +3217 -> 3220 call = (...) => (???*0* | b)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15574,7 +19366,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[4] ⚠️ function calls are not analysed yet -0 -> 2626 conditional = (("object" === ???*0*) | (null !== ???*2*)) +3217 -> 3221 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3217 -> 3222 conditional = (("object" === ???*0*) | (null !== ???*2*)) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[3] @@ -15582,13 +19378,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2630 conditional = (null === ???*0*) +3222 -> 3226 conditional = (null === ???*0*) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2632 member call = (???*0* | ???*1* | null)["get"]((???*3* ? ???*6* : ???*7*)) +3222 -> 3228 member call = (???*0* | ???*1* | null)["get"]((???*3* ? ???*6* : ???*7*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["get"](c) @@ -15608,7 +19404,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2633 call = (...) => (m(a, b, c["props"]["children"], d, c["key"]) | ???*0* | d)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*) +3222 -> 3229 call = (...) => (m(a, b, c["props"]["children"], d, c["key"]) | ???*0* | d)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*) - *0* d ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15625,13 +19421,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[4] ⚠️ function calls are not analysed yet -2626 -> 2636 conditional = (null === ???*0*) +3222 -> 3230 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3222 -> 3233 conditional = (null === ???*0*) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2638 member call = (???*0* | ???*1* | null)["get"]((???*3* ? ???*6* : ???*7*)) +3222 -> 3235 member call = (???*0* | ???*1* | null)["get"]((???*3* ? ???*6* : ???*7*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["get"](c) @@ -15651,7 +19451,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2639 call = (...) => (???*0* | b)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*) +3222 -> 3236 call = (...) => (???*0* | b)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15668,7 +19468,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[4] ⚠️ function calls are not analysed yet -2626 -> 2642 call = ???*0*(???*2*) +3222 -> 3237 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3222 -> 3240 call = ???*0*(???*2*) - *0* ???*1*["_init"] ⚠️ unknown object - *1* arguments[3] @@ -15678,7 +19482,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2643 call = (...) => (???*0* | y(a, b, c, f(d["_payload"]), e) | null)((???*1* | ???*2* | null), ???*4*, ???*5*, ???*6*, ???*9*) +3222 -> 3241 call = (...) => (???*0* | y(a, b, c, f(d["_payload"]), e) | null)((???*1* | ???*2* | null), ???*4*, ???*5*, ???*6*, ???*9*) - *0* h(b, a, ("" + d), e) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15701,7 +19505,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[4] ⚠️ function calls are not analysed yet -2626 -> 2644 call = ???*0*(???*2*) +3222 -> 3242 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3222 -> 3243 call = ???*0*(???*2*) - *0* ???*1*["isArray"] ⚠️ unknown object ⚠️ This value might have side effects @@ -15711,11 +19519,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2645 call = (...) => (null | (("function" === typeof(a)) ? a : null))(???*0*) +3222 -> 3244 call = (...) => (null | (("function" === typeof(a)) ? a : null))(???*0*) - *0* arguments[3] ⚠️ function calls are not analysed yet -2626 -> 2646 conditional = (???*0* | null | (???*3* ? (???*10* | ???*11* | ???*13*) : null)) +3222 -> 3245 conditional = (???*0* | null | (???*3* ? (???*10* | ???*11* | ???*13*) : null)) - *0* ???*1*(d) ⚠️ unknown callee ⚠️ This value might have side effects @@ -15754,7 +19562,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* a ⚠️ circular variable reference -2646 -> 2648 member call = (???*0* | ???*1* | null)["get"](???*3*) +3245 -> 3247 member call = (???*0* | ???*1* | null)["get"](???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["get"](c) @@ -15764,7 +19572,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -2646 -> 2649 call = (...) => (???*0* | b)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*, null) +3245 -> 3248 call = (...) => (???*0* | b)(???*1*, (???*2* | ???*3* | null), ???*5*, ???*6*, null) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15781,13 +19589,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[4] ⚠️ function calls are not analysed yet -2626 -> 2650 call = (...) => undefined(???*0*, ???*1*) +3245 -> 3249 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3245 -> 3250 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2655 call = (...) => ( +3217 -> 3251 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3256 call = (...) => ( | ((null !== e) ? null : h(a, b, `${c}`, d)) | ((c["key"] === e) ? k(a, b, c, d) : null) | ((c["key"] === e) ? l(a, b, c, d) : null) @@ -15809,13 +19625,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2657 call = (...) => undefined(???*0*, ???*1*) +0 -> 3258 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2658 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) +0 -> 3259 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) - *0* c ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15828,11 +19644,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -0 -> 2659 conditional = ???*0* +0 -> 3260 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2662 conditional = ((???*0* | ???*1*) === ???*2*) +0 -> 3263 conditional = ((???*0* | ???*1*) === ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* updated with update expression @@ -15842,13 +19658,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -2662 -> 2663 call = (...) => null(???*0*, ???*1*) +3263 -> 3264 call = (...) => null(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2662 -> 2664 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3263 -> 3265 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -15856,11 +19672,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* updated with update expression ⚠️ This value might have side effects -0 -> 2665 conditional = ???*0* +3263 -> 3266 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3263 -> 3267 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2665 -> 2668 call = (...) => (???*0* | q(a, d(b["_payload"]), c) | null)(???*1*, ???*2*, ???*4*) +3267 -> 3270 call = (...) => (???*0* | q(a, d(b["_payload"]), c) | null)(???*1*, ???*2*, ???*4*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15873,7 +19693,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -2665 -> 2669 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) +3267 -> 3271 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) - *0* c ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15886,11 +19706,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -2665 -> 2670 conditional = ???*0* +3267 -> 3272 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2665 -> 2672 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3267 -> 3274 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -15898,13 +19718,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* updated with update expression ⚠️ This value might have side effects -0 -> 2673 call = (...) => a(???*0*, ???*1*) +3267 -> 3275 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3267 -> 3276 call = (...) => a(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2676 call = (...) => (???*0* | y(a, b, c, f(d["_payload"]), e) | null)(???*1*, ???*2*, (???*3* | ???*4*), ???*5*, ???*7*) +3267 -> 3279 call = (...) => (???*0* | y(a, b, c, f(d["_payload"]), e) | null)(???*1*, ???*2*, (???*3* | ???*4*), ???*5*, ???*7*) - *0* h(b, a, ("" + d), e) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15923,17 +19747,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2680 conditional = ???*0* +3267 -> 3283 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2682 member call = ???*0*["delete"](???*1*) +3267 -> 3285 member call = ???*0*["delete"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2683 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) +3267 -> 3286 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) - *0* c ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -15946,21 +19770,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -0 -> 2684 conditional = ???*0* +3267 -> 3287 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2687 member call = ???*0*["forEach"]((...) => b(e, a)) +3267 -> 3290 member call = ???*0*["forEach"]((...) => b(e, a)) - *0* max number of linking steps reached ⚠️ This value might have side effects -2687 -> 2688 call = (...) => undefined(???*0*, ???*1*) +3290 -> 3291 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2689 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3290 -> 3292 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3267 -> 3293 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -15968,19 +19796,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* updated with update expression ⚠️ This value might have side effects -0 -> 2690 call = (...) => (null | (("function" === typeof(a)) ? a : null))(???*0*) +3267 -> 3294 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3295 call = (...) => (null | (("function" === typeof(a)) ? a : null))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2691 conditional = ???*0* +0 -> 3296 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2691 -> 2692 free var = FreeVar(Error) +3296 -> 3297 free var = FreeVar(Error) -2691 -> 2693 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(150) +3296 -> 3298 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(150) -2691 -> 2694 call = ???*0*( +3296 -> 3299 call = ???*0*( `Minified React error #${150}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -15989,21 +19821,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${150}` ⚠️ nested operation -0 -> 2696 member call = ???*0*["call"](???*1*) +0 -> 3301 member call = ???*0*["call"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2697 conditional = ???*0* +0 -> 3302 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2697 -> 2698 free var = FreeVar(Error) +3302 -> 3303 free var = FreeVar(Error) -2697 -> 2699 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(151) +3302 -> 3304 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(151) -2697 -> 2700 call = ???*0*( +3302 -> 3305 call = ???*0*( `Minified React error #${151}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -16012,15 +19844,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${151}` ⚠️ nested operation -0 -> 2702 member call = ???*0*["next"]() +0 -> 3307 member call = ???*0*["next"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2705 member call = ???*0*["next"]() +0 -> 3310 member call = ???*0*["next"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2709 call = (...) => ( +0 -> 3314 call = (...) => ( | ((null !== e) ? null : h(a, b, `${c}`, d)) | ((c["key"] === e) ? k(a, b, c, d) : null) | ((c["key"] === e) ? l(a, b, c, d) : null) @@ -16040,13 +19872,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2711 call = (...) => undefined(???*0*, ???*1*) +0 -> 3316 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2712 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) +0 -> 3317 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) - *0* c ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -16059,21 +19891,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -0 -> 2713 conditional = ???*0* +0 -> 3318 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2716 conditional = ???*0* +0 -> 3321 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2716 -> 2717 call = (...) => null(???*0*, ???*1*) +3321 -> 3322 call = (...) => null(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -2716 -> 2718 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3321 -> 3323 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -16081,15 +19913,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* updated with update expression ⚠️ This value might have side effects -0 -> 2719 conditional = ???*0* +3321 -> 3324 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3321 -> 3325 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2719 -> 2722 member call = ???*0*["next"]() +3325 -> 3328 member call = ???*0*["next"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -2719 -> 2724 call = (...) => (???*0* | q(a, d(b["_payload"]), c) | null)(???*1*, ???*2*, ???*3*) +3325 -> 3330 call = (...) => (???*0* | q(a, d(b["_payload"]), c) | null)(???*1*, ???*2*, ???*3*) - *0* b ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -16100,7 +19936,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -2719 -> 2725 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) +3325 -> 3331 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) - *0* c ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -16113,11 +19949,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -2719 -> 2726 conditional = ???*0* +3325 -> 3332 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2719 -> 2728 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3325 -> 3334 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -16125,17 +19961,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* updated with update expression ⚠️ This value might have side effects -0 -> 2729 call = (...) => a(???*0*, ???*1*) +3325 -> 3335 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3325 -> 3336 call = (...) => a(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2732 member call = ???*0*["next"]() +3325 -> 3339 member call = ???*0*["next"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2734 call = (...) => (???*0* | y(a, b, c, f(d["_payload"]), e) | null)(???*1*, ???*2*, (???*3* | ???*4*), ???*5*, ???*6*) +3325 -> 3341 call = (...) => (???*0* | y(a, b, c, f(d["_payload"]), e) | null)(???*1*, ???*2*, (???*3* | ???*4*), ???*5*, ???*6*) - *0* h(b, a, ("" + d), e) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -16152,17 +19992,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[3] ⚠️ function calls are not analysed yet -0 -> 2738 conditional = ???*0* +3325 -> 3345 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2740 member call = ???*0*["delete"](???*1*) +3325 -> 3347 member call = ???*0*["delete"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2741 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) +3325 -> 3348 call = (...) => (???*0* | c)(???*1*, ???*2*, (???*3* | ???*4*)) - *0* c ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -16175,21 +20015,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* updated with update expression ⚠️ This value might have side effects -0 -> 2742 conditional = ???*0* +3325 -> 3349 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2745 member call = ???*0*["forEach"]((...) => b(e, a)) +3325 -> 3352 member call = ???*0*["forEach"]((...) => b(e, a)) - *0* max number of linking steps reached ⚠️ This value might have side effects -2745 -> 2746 call = (...) => undefined(???*0*, ???*1*) +3352 -> 3353 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2747 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3352 -> 3354 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3325 -> 3355 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -16197,7 +20041,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* updated with update expression ⚠️ This value might have side effects -0 -> 2752 conditional = (("object" === ???*0*) | (null !== (???*6* | ???*7* | ???*10*))) +3325 -> 3356 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3361 conditional = (("object" === ???*0*) | (null !== (???*6* | ???*7* | ???*10*))) - *0* typeof((???*1* | ???*2* | ???*5*)) ⚠️ nested operation - *1* arguments[2] @@ -16221,11 +20069,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* f ⚠️ circular variable reference -2752 -> 2756 conditional = ???*0* +3361 -> 3365 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2756 -> 2758 conditional = (???*0* === ???*2*) +3365 -> 3367 conditional = (???*0* === ???*2*) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[2] @@ -16237,17 +20085,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2758 -> 2760 conditional = ???*0* +3367 -> 3369 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2760 -> 2762 call = (...) => null(???*0*, ???*1*) +3369 -> 3371 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2760 -> 2765 call = (...) => a(???*0*, ???*1*) +3369 -> 3374 call = (...) => a(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* ???*2*["children"] @@ -16257,23 +20105,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -2758 -> 2769 call = (...) => b(a["_payload"])(???*0*) +3367 -> 3378 call = (...) => b(a["_payload"])(???*0*) - *0* ???*1*["key"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -2758 -> 2771 conditional = ???*0* +3367 -> 3380 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2771 -> 2773 call = (...) => null(???*0*, ???*1*) +3380 -> 3382 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2771 -> 2775 call = (...) => a(???*0*, ???*1*) +3380 -> 3384 call = (...) => a(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* ???*2*["props"] @@ -16281,7 +20129,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2771 -> 2777 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, (???*2* | ???*3* | ???*6*)) +3380 -> 3386 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, (???*2* | ???*3* | ???*6*)) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -16297,19 +20145,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* f ⚠️ circular variable reference -2756 -> 2779 call = (...) => null(???*0*, ???*1*) +3365 -> 3388 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2756 -> 2780 call = (...) => undefined(???*0*, ???*1*) +3365 -> 3389 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2783 conditional = (???*0* === ???*2*) +3361 -> 3392 conditional = (???*0* === ???*2*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[2] @@ -16321,7 +20169,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2783 -> 2788 call = (...) => a(???*0*, ???*3*, ???*4*, ???*5*) +3392 -> 3397 call = (...) => a(???*0*, ???*3*, ???*4*, ???*5*) - *0* ???*1*["children"] ⚠️ unknown object - *1* ???*2*["props"] @@ -16337,7 +20185,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[2] ⚠️ function calls are not analysed yet -2783 -> 2794 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)(???*1*, ???*3*, ???*5*, null, ???*7*, ???*8*) +3392 -> 3403 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)(???*1*, ???*3*, ???*5*, null, ???*7*, ???*8*) - *0* a ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -16358,7 +20206,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* max number of linking steps reached ⚠️ This value might have side effects -2783 -> 2796 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, (???*2* | ???*3* | ???*6*)) +3392 -> 3405 call = (...) => (b["ref"] | b | a)(???*0*, ???*1*, (???*2* | ???*3* | ???*6*)) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -16374,25 +20222,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* f ⚠️ circular variable reference -2752 -> 2798 call = (...) => b(???*0*) +3361 -> 3407 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2801 conditional = ???*0* +3361 -> 3408 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3361 -> 3411 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2801 -> 2809 conditional = ???*0* +3411 -> 3419 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2809 -> 2811 call = (...) => null(???*0*, ???*1*) +3419 -> 3421 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2809 -> 2813 call = (...) => a(???*0*, (???*1* | []){truthy}) +3419 -> 3423 call = (...) => a(???*0*, (???*1* | []){truthy}) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* ???*2*["children"] @@ -16400,19 +20252,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2809 -> 2815 call = (...) => null(???*0*, ???*1*) +3419 -> 3425 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2801 -> 2816 call = (...) => undefined(???*0*, ???*1*) +3411 -> 3426 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2819 call = (...) => b((???*0* | ???*1* | ???*4*), ???*5*, ???*6*) +3361 -> 3429 call = (...) => b((???*0* | ???*1* | ???*4*), ???*5*, ???*6*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["children"] @@ -16428,11 +20280,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2821 call = (...) => b(???*0*) +3361 -> 3431 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2824 call = ???*0*(???*1*) +3361 -> 3432 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3361 -> 3435 call = ???*0*(???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* ???*2*["_payload"] @@ -16440,7 +20296,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[2] ⚠️ function calls are not analysed yet -2752 -> 2825 call = (...) => ( +3361 -> 3436 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -16462,7 +20318,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2826 call = ???*0*((???*2* | ???*3* | ???*6*)) +3361 -> 3437 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3361 -> 3438 call = ???*0*((???*2* | ???*3* | ???*6*)) - *0* ???*1*["isArray"] ⚠️ unknown object ⚠️ This value might have side effects @@ -16480,7 +20340,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* f ⚠️ circular variable reference -2752 -> 2827 conditional = ???*0* +3361 -> 3439 conditional = ???*0* - *0* ???*1*(f) ⚠️ unknown callee ⚠️ This value might have side effects @@ -16491,7 +20351,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2827 -> 2828 call = (...) => l(???*0*, ???*1*, (???*2* | ???*3* | ???*6*), ???*7*) +3439 -> 3440 call = (...) => l(???*0*, ???*1*, (???*2* | ???*3* | ???*6*), ???*7*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -16509,7 +20369,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2829 call = (...) => (null | (("function" === typeof(a)) ? a : null))((???*0* | ???*1* | ???*4*)) +3439 -> 3441 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3439 -> 3442 call = (...) => (null | (("function" === typeof(a)) ? a : null))((???*0* | ???*1* | ???*4*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["children"] @@ -16521,7 +20385,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* f ⚠️ circular variable reference -2752 -> 2830 conditional = ( +3439 -> 3443 conditional = ( | null | (???*0* ? (???*9* | ???*10* | ???*13* | ???*14*) : null) ) @@ -16562,7 +20426,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -2830 -> 2831 call = (...) => l(???*0*, ???*1*, (???*2* | ???*3* | ???*6*), ???*7*) +3443 -> 3444 call = (...) => l(???*0*, ???*1*, (???*2* | ???*3* | ???*6*), ???*7*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -16580,7 +20444,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* max number of linking steps reached ⚠️ This value might have side effects -2752 -> 2832 call = (...) => undefined(???*0*, (???*1* | ???*2* | ???*5*)) +3443 -> 3445 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3443 -> 3446 call = (...) => undefined(???*0*, (???*1* | ???*2* | ???*5*)) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[2] @@ -16594,7 +20462,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* f ⚠️ circular variable reference -0 -> 2833 conditional = (("string" === ???*0*) | ("" !== (???*6* | ???*7* | ???*10*)) | ("number" === ???*11*)) +0 -> 3447 conditional = (("string" === ???*0*) | ("" !== (???*6* | ???*7* | ???*10*)) | ("number" === ???*11*)) - *0* typeof((???*1* | ???*2* | ???*5*)) ⚠️ nested operation - *1* arguments[2] @@ -16630,17 +20498,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* f ⚠️ circular variable reference -2833 -> 2835 conditional = ???*0* +3447 -> 3449 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2835 -> 2837 call = (...) => null(???*0*, ???*1*) +3449 -> 3451 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2835 -> 2838 call = (...) => a(???*0*, (???*1* | ???*2* | ???*5*)) +3449 -> 3452 call = (...) => a(???*0*, (???*1* | ???*2* | ???*5*)) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[2] @@ -16654,13 +20522,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* f ⚠️ circular variable reference -2835 -> 2840 call = (...) => null(???*0*, ???*1*) +3449 -> 3454 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -2835 -> 2842 call = (...) => a((???*0* | ???*1* | ???*4*), ???*5*, ???*6*) +3449 -> 3456 call = (...) => a((???*0* | ???*1* | ???*4*), ???*5*, ???*6*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["children"] @@ -16676,35 +20544,39 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* max number of linking steps reached ⚠️ This value might have side effects -2833 -> 2844 call = (...) => b(???*0*) +3447 -> 3458 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -2833 -> 2845 call = (...) => null(???*0*, ???*1*) +3447 -> 3459 call = (...) => null(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2846 call = (...) => J(true) +0 -> 3460 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 2847 call = (...) => J(false) +0 -> 3461 call = (...) => J(true) -0 -> 2848 call = (...) => {"current": a}({}) +0 -> 3462 call = (...) => J(false) -0 -> 2849 call = (...) => {"current": a}({}) +0 -> 3463 call = (...) => {"current": a}({}) -0 -> 2850 call = (...) => {"current": a}({}) +0 -> 3464 call = (...) => {"current": a}({}) -0 -> 2851 conditional = (???*0* === {}) +0 -> 3465 call = (...) => {"current": a}({}) + +0 -> 3466 conditional = (???*0* === {}) - *0* arguments[0] ⚠️ function calls are not analysed yet -2851 -> 2852 free var = FreeVar(Error) +3466 -> 3467 free var = FreeVar(Error) -2851 -> 2853 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(174) +3466 -> 3468 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(174) -2851 -> 2854 call = ???*0*( +3466 -> 3469 call = ???*0*( `Minified React error #${174}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -16713,7 +20585,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${174}` ⚠️ nested operation -0 -> 2855 call = (...) => undefined( +0 -> 3470 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3471 call = (...) => undefined( {"current": {}}, ( | ???*0* @@ -16773,7 +20649,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* b ⚠️ circular variable reference -0 -> 2856 call = (...) => undefined( +0 -> 3472 call = (...) => undefined( {"current": {}}, ( | ???*0* @@ -16854,11 +20730,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* b ⚠️ circular variable reference -0 -> 2857 call = (...) => undefined({"current": {}}, {}) +0 -> 3473 call = (...) => undefined({"current": {}}, {}) -0 -> 2861 call = (...) => (((null == a) || ("http://www.w3.org/1999/xhtml" === a)) ? kb(b) : ((("http://www.w3.org/2000/svg" === a) && ("foreignObject" === b)) ? "http://www.w3.org/1999/xhtml" : a))(null, "") +0 -> 3477 call = (...) => (((null == a) || ("http://www.w3.org/1999/xhtml" === a)) ? kb(b) : ((("http://www.w3.org/2000/svg" === a) && ("foreignObject" === b)) ? "http://www.w3.org/1999/xhtml" : a))(null, "") -0 -> 2862 conditional = (8 === (???*0* | ???*1* | null["nodeType"] | ???*3*)) +0 -> 3478 conditional = (8 === (???*0* | ???*1* | null["nodeType"] | ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["nodeType"] @@ -16899,7 +20775,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* b ⚠️ circular variable reference -0 -> 2866 call = (...) => (((null == a) || ("http://www.w3.org/1999/xhtml" === a)) ? kb(b) : ((("http://www.w3.org/2000/svg" === a) && ("foreignObject" === b)) ? "http://www.w3.org/1999/xhtml" : a))( +0 -> 3482 call = (...) => (((null == a) || ("http://www.w3.org/1999/xhtml" === a)) ? kb(b) : ((("http://www.w3.org/2000/svg" === a) && ("foreignObject" === b)) ? "http://www.w3.org/1999/xhtml" : a))( ( | ???*0* | (???*1* ? ???*2* : ???*4*) @@ -17035,9 +20911,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *45* b ⚠️ circular variable reference -0 -> 2867 call = (...) => undefined({"current": {}}) +0 -> 3483 call = (...) => undefined({"current": {}}) -0 -> 2868 call = (...) => undefined( +0 -> 3484 call = (...) => undefined( {"current": {}}, ( | ???*0* @@ -17097,21 +20973,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* b ⚠️ circular variable reference -0 -> 2869 call = (...) => undefined({"current": {}}) +0 -> 3485 call = (...) => undefined({"current": {}}) -0 -> 2870 call = (...) => undefined({"current": {}}) +0 -> 3486 call = (...) => undefined({"current": {}}) -0 -> 2871 call = (...) => undefined({"current": {}}) +0 -> 3487 call = (...) => undefined({"current": {}}) -0 -> 2873 call = (...) => a(({} | ???*0*)) +0 -> 3489 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -0 -> 2875 call = (...) => a(({} | ???*0*)) +0 -> 3491 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -0 -> 2877 call = (...) => (((null == a) || ("http://www.w3.org/1999/xhtml" === a)) ? kb(b) : ((("http://www.w3.org/2000/svg" === a) && ("foreignObject" === b)) ? "http://www.w3.org/1999/xhtml" : a))(({} | ???*0*), ???*1*) +0 -> 3493 call = (...) => (((null == a) || ("http://www.w3.org/1999/xhtml" === a)) ? kb(b) : ((("http://www.w3.org/2000/svg" === a) && ("foreignObject" === b)) ? "http://www.w3.org/1999/xhtml" : a))(({} | ???*0*), ???*1*) - *0* unknown mutation ⚠️ This value might have side effects - *1* ???*2*["type"] @@ -17119,11 +20995,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2878 call = (...) => undefined({"current": {}}, ???*0*) +0 -> 3494 call = (...) => undefined({"current": {}}, ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2879 call = (...) => undefined( +0 -> 3495 call = (...) => undefined( {"current": {}}, (???*0* ? ( | undefined @@ -17145,19 +21021,32 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -0 -> 2881 call = (...) => undefined({"current": {}}) +0 -> 3497 call = (...) => undefined({"current": {}}) -0 -> 2882 call = (...) => undefined({"current": {}}) +0 -> 3498 call = (...) => undefined({"current": {}}) -0 -> 2883 call = (...) => {"current": a}(0) +0 -> 3499 call = (...) => {"current": a}(0) -0 -> 2885 conditional = (13 === ???*0*) +0 -> 3501 conditional = (13 === ???*0*) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -2885 -> 2893 conditional = ((19 === ???*0*) | (???*2* !== ???*3*)) +3501 -> 3506 conditional = ((null !== ???*0*) | ???*2*) +- *0* ???*1*["memoizedState"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* (((null === c) || ("$?" === c["data"])) || ("$!" === c["data"])) + ⚠️ sequence with side effects + ⚠️ This value might have side effects + +3506 -> 3507 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3501 -> 3511 conditional = ((19 === ???*0*) | (???*2* !== ???*3*)) - *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] @@ -17171,17 +21060,45 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -2893 -> 2896 conditional = (null !== ???*0*) +3511 -> 3513 conditional = (0 !== ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects + +3513 -> 3514 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3511 -> 3516 conditional = (null !== ???*0*) - *0* ???*1*["child"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2914 free var = FreeVar(Error) +0 -> 3523 conditional = ((null === ???*0*) | (???*2* === ???*4*)) +- *0* ???*1*["return"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["return"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* arguments[0] + ⚠️ function calls are not analysed yet + +3523 -> 3524 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3530 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 2915 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(321) +0 -> 3537 free var = FreeVar(Error) -0 -> 2916 call = ???*0*( +0 -> 3538 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(321) + +0 -> 3539 call = ???*0*( `Minified React error #${321}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -17190,7 +21107,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${321}` ⚠️ nested operation -0 -> 2921 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*11*) +0 -> 3540 conditional = (null === ???*0*) +- *0* arguments[1] + ⚠️ function calls are not analysed yet + +3540 -> 3541 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3540 -> 3546 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*11*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -17222,7 +21147,48 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[1] ⚠️ function calls are not analysed yet -0 -> 2927 conditional = ((null === (???*0* | ???*1*)) | (null === ???*3*)) +3540 -> 3547 conditional = !(???*0*) +- *0* ???*1*(???*10*, ???*12*) + ⚠️ unknown callee +- *1* (???*2* ? ???*5* : (...) => ???*7*) + ⚠️ nested operation +- *2* ("function" === ???*3*) + ⚠️ nested operation +- *3* typeof(???*4*) + ⚠️ nested operation +- *4* ???["is"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *5* ???*6*["is"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects +- *7* (((a === b) && ((0 !== a) || (???*8* === ???*9*))) || ((a !== a) && (b !== b))) + ⚠️ nested operation +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* ???*11*[c] + ⚠️ unknown object +- *11* arguments[0] + ⚠️ function calls are not analysed yet +- *12* ???*13*[c] + ⚠️ unknown object +- *13* arguments[1] + ⚠️ function calls are not analysed yet + +3547 -> 3548 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3547 -> 3549 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3555 conditional = ((null === (???*0* | ???*1*)) | (null === ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*(d, e) @@ -17234,7 +21200,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2928 call = ???*0*(???*1*, ???*2*) +0 -> 3556 call = ???*0*(???*1*, ???*2*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[3] @@ -17242,15 +21208,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 2929 conditional = (false | ???*0*) +0 -> 3557 conditional = (false | ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -2929 -> 2930 free var = FreeVar(Error) +3557 -> 3558 free var = FreeVar(Error) -2929 -> 2931 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(301) +3557 -> 3559 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(301) -2929 -> 2932 call = ???*0*( +3557 -> 3560 call = ???*0*( `Minified React error #${301}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -17259,7 +21225,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${301}` ⚠️ nested operation -2929 -> 2935 call = ???*0*(???*1*, ???*2*) +3557 -> 3563 call = ???*0*(???*1*, ???*2*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[3] @@ -17267,7 +21233,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 2938 conditional = ( +0 -> 3566 conditional = ( | ???*0* | (null !== ( | null @@ -17333,11 +21299,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *22* unknown mutation ⚠️ This value might have side effects -2938 -> 2939 free var = FreeVar(Error) +3566 -> 3567 free var = FreeVar(Error) -2938 -> 2940 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(300) +3566 -> 3568 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(300) -2938 -> 2941 call = ???*0*( +3566 -> 3569 call = ???*0*( `Minified React error #${300}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -17346,7 +21312,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${300}` ⚠️ nested operation -0 -> 2942 conditional = (null === ( +0 -> 3570 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3571 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3572 conditional = (null === ( | null | ???*0* | {"memoizedState": null, "baseState": null, "baseQueue": null, "queue": null, "next": null} @@ -17425,7 +21399,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *27* a ⚠️ circular variable reference -0 -> 2945 conditional = (null === ( +0 -> 3575 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3576 conditional = (null === ( | null | ???*0* | null["alternate"] @@ -17472,7 +21450,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* O ⚠️ circular variable reference -2945 -> 2947 conditional = (null !== ( +3576 -> 3578 conditional = (null !== ( | null["alternate"] | ???*0* | ???*2* @@ -17542,7 +21520,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *24* a ⚠️ circular variable reference -0 -> 2950 conditional = (null === ( +0 -> 3581 conditional = (null === ( | null | ???*0* | {"memoizedState": null, "baseState": null, "baseQueue": null, "queue": null, "next": null} @@ -17621,11 +21599,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *27* a ⚠️ circular variable reference -0 -> 2953 conditional = ???*0* +0 -> 3584 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2953 -> 2954 conditional = (null === ( +3584 -> 3585 conditional = (null === ( | null["alternate"] | ???*0* | ???*2* @@ -17695,11 +21673,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *24* a ⚠️ circular variable reference -2954 -> 2955 free var = FreeVar(Error) +3585 -> 3586 free var = FreeVar(Error) -2954 -> 2956 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(310) +3585 -> 3587 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(310) -2954 -> 2957 call = ???*0*( +3585 -> 3588 call = ???*0*( `Minified React error #${310}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -17708,7 +21686,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${310}` ⚠️ nested operation -2953 -> 2962 conditional = (null === ( +3584 -> 3593 conditional = (null === ( | null | ???*0* | {"memoizedState": null, "baseState": null, "baseQueue": null, "queue": null, "next": null} @@ -17787,29 +21765,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *27* a ⚠️ circular variable reference -0 -> 2965 conditional = ("function" === ???*0*) +0 -> 3596 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3597 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[1] ⚠️ function calls are not analysed yet -2965 -> 2966 call = ???*0*(???*1*) +3597 -> 3598 call = ???*0*(???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 2967 call = (...) => P() +0 -> 3599 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3600 call = (...) => P() -0 -> 2969 conditional = ???*0* +0 -> 3602 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2969 -> 2970 free var = FreeVar(Error) +3602 -> 3603 free var = FreeVar(Error) -2969 -> 2971 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(311) +3602 -> 3604 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(311) -2969 -> 2972 call = ???*0*( +3602 -> 3605 call = ???*0*( `Minified React error #${311}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -17818,27 +21804,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${311}` ⚠️ nested operation -0 -> 2976 conditional = ???*0* +0 -> 3609 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2976 -> 2977 conditional = ???*0* +3609 -> 3610 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 2984 conditional = ???*0* +0 -> 3617 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2984 -> 2988 conditional = ???*0* +3617 -> 3621 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2988 -> 2994 conditional = ???*0* +3621 -> 3627 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2994 -> 2997 call = ???*0*(???*1*, ???*2*) +3627 -> 3630 call = ???*0*(???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -17846,15 +21832,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -2988 -> 3001 conditional = ???*0* +3621 -> 3634 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2984 -> 3005 conditional = ???*0* +3617 -> 3638 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -2984 -> 3008 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) +3617 -> 3641 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -17882,21 +21868,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3014 conditional = ???*0* +0 -> 3647 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3021 call = (...) => P() +0 -> 3654 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3655 call = (...) => P() -0 -> 3023 conditional = ???*0* +0 -> 3657 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3023 -> 3024 free var = FreeVar(Error) +3657 -> 3658 free var = FreeVar(Error) -3023 -> 3025 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(311) +3657 -> 3659 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(311) -3023 -> 3026 call = ???*0*( +3657 -> 3660 call = ???*0*( `Minified React error #${311}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -17905,11 +21895,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${311}` ⚠️ nested operation -0 -> 3031 conditional = ???*0* +0 -> 3665 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3031 -> 3035 call = ???*0*(???*1*, (???*2* | ???*4*)) +3665 -> 3669 call = ???*0*(???*1*, (???*2* | ???*4*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached @@ -17926,7 +21916,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* g ⚠️ circular variable reference -3031 -> 3038 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) +3665 -> 3672 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -17954,13 +21944,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3043 call = (...) => P() +0 -> 3677 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3044 call = ???*0*() +0 -> 3678 call = (...) => P() + +0 -> 3679 call = ???*0*() - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3046 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*()) +0 -> 3681 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*()) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -17988,7 +21982,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3050 member call = (...) => c(*anonymous function 67764*)["bind"]( +0 -> 3685 member call = (...) => c(*anonymous function 67764*)["bind"]( null, ( | null @@ -18160,17 +22154,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *60* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3051 call = (...) => ui(2048, 8, a, b)(???*0*, [???*1*]) +0 -> 3686 call = (...) => ui(2048, 8, a, b)(???*0*, [???*1*]) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3055 conditional = ???*0* +0 -> 3690 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3055 -> 3058 member call = (...) => undefined["bind"]( +3690 -> 3693 member call = (...) => undefined["bind"]( null, ( | null @@ -18345,13 +22339,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *61* arguments[1] ⚠️ function calls are not analysed yet -3055 -> 3059 call = (...) => a(9, ???*0*, ???*1*, null) +3690 -> 3694 call = (...) => a(9, ???*0*, ???*1*, null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -3055 -> 3060 conditional = (null === (null | ???*0* | ???*1* | ???*4*)) +3690 -> 3695 conditional = (null === (null | ???*0* | ???*1* | ???*4*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["alternate"] @@ -18363,11 +22357,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unknown new expression ⚠️ This value might have side effects -3060 -> 3061 free var = FreeVar(Error) +3695 -> 3696 free var = FreeVar(Error) -3060 -> 3062 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(349) +3695 -> 3697 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(349) -3060 -> 3063 call = ???*0*( +3695 -> 3698 call = ???*0*( `Minified React error #${349}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -18376,7 +22370,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${349}` ⚠️ nested operation -3055 -> 3064 call = (...) => undefined( +3690 -> 3699 call = (...) => undefined( ( | null | ???*0* @@ -18450,7 +22444,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *24* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3067 conditional = (null === (???*0* | null["updateQueue"] | ???*1* | {"lastEffect": null, "stores": null})) +0 -> 3700 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3703 conditional = (null === (???*0* | null["updateQueue"] | ???*1* | {"lastEffect": null, "stores": null})) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["updateQueue"] @@ -18458,7 +22456,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -3067 -> 3071 conditional = (null === (???*0* | ???*1* | null["updateQueue"]["stores"] | null | ???*3*)) +3703 -> 3707 conditional = (null === (???*0* | ???*1* | null["updateQueue"]["stores"] | null | ???*3*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["stores"] @@ -18468,7 +22466,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unknown mutation ⚠️ This value might have side effects -3071 -> 3074 member call = ( +3707 -> 3710 member call = ( | ???*0* | ???*1* | null["updateQueue"]["stores"] @@ -18545,33 +22543,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3077 call = (...) => (undefined | !(He(a, c)) | !(0))(???*0*) +0 -> 3713 call = (...) => (undefined | !(He(a, c)) | !(0))(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3078 call = (...) => undefined(???*0*) +0 -> 3714 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3079 call = ???*0*((...) => undefined) +0 -> 3715 call = ???*0*((...) => undefined) - *0* arguments[2] ⚠️ function calls are not analysed yet -3079 -> 3080 call = (...) => (undefined | !(He(a, c)) | !(0))(???*0*) +3715 -> 3716 call = (...) => (undefined | !(He(a, c)) | !(0))(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -3079 -> 3081 call = (...) => undefined(???*0*) +3715 -> 3717 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3084 call = ???*0*() +0 -> 3718 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3721 call = ???*0*() - *0* ???*1*["getSnapshot"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3085 call = (???*0* ? ???*4* : (...) => ???*6*)((???*9* | ???*10*), ???*12*()) +0 -> 3722 call = (???*0* ? ???*4* : (...) => ???*6*)((???*9* | ???*10*), ???*12*()) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -18605,11 +22607,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3086 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, 1) +0 -> 3723 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3724 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3725 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, 1) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3087 call = (...) => undefined((???*0* ? ???*4* : null), ???*7*, 1, ???*8*) +0 -> 3726 call = (...) => undefined((???*0* ? ???*4* : null), ???*7*, 1, ???*8*) - *0* (3 === ???*1*) ⚠️ nested operation - *1* ???*2*["tag"] @@ -18629,9 +22639,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unsupported expression ⚠️ This value might have side effects -0 -> 3088 call = (...) => P() +0 -> 3727 call = (...) => P() -0 -> 3089 call = ( +0 -> 3728 call = ( | ???*0* | ???*1*() | { @@ -18653,7 +22663,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -0 -> 3095 member call = (...) => (undefined | FreeVar(undefined))["bind"]( +0 -> 3734 member call = (...) => (undefined | FreeVar(undefined))["bind"]( null, ( | null @@ -18743,7 +22753,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* unsupported expression ⚠️ This value might have side effects -0 -> 3098 conditional = (null === (???*0* | null["updateQueue"] | ???*1* | {"lastEffect": null, "stores": null})) +0 -> 3736 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3738 conditional = (null === (???*0* | null["updateQueue"] | ???*1* | {"lastEffect": null, "stores": null})) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["updateQueue"] @@ -18751,7 +22765,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -3098 -> 3103 conditional = (null === (???*0* | ???*1* | null["updateQueue"]["lastEffect"] | null | ???*3*)) +3738 -> 3743 conditional = (null === (???*0* | ???*1* | null["updateQueue"]["lastEffect"] | null | ???*3*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["lastEffect"] @@ -18761,17 +22775,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unknown mutation ⚠️ This value might have side effects -0 -> 3111 call = (...) => P() +0 -> 3750 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3752 call = (...) => P() + +0 -> 3753 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3112 call = (...) => P() +0 -> 3754 call = (...) => P() -0 -> 3115 conditional = (???*0* === ???*1*) +0 -> 3757 conditional = (???*0* === ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[3] ⚠️ function calls are not analysed yet -0 -> 3116 call = (...) => a(???*0*, ???*1*, ???*2*, (???*3* ? null : ???*6*)) +0 -> 3758 call = (...) => a(???*0*, ???*1*, ???*2*, (???*3* ? null : ???*6*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] @@ -18787,9 +22809,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[3] ⚠️ function calls are not analysed yet -0 -> 3117 call = (...) => P() +0 -> 3759 call = (...) => P() -0 -> 3118 conditional = (???*0* === (???*1* | ???*2*)) +0 -> 3760 conditional = (???*0* === (???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[3] @@ -18805,7 +22827,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* d ⚠️ circular variable reference -0 -> 3119 conditional = (null !== ( +0 -> 3761 conditional = (null !== ( | null | ???*0* | null["alternate"] @@ -18852,7 +22874,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* O ⚠️ circular variable reference -3119 -> 3123 call = (...) => (!(1) | !(0))( +3761 -> 3765 call = (...) => (!(1) | !(0))( (???*0* | (???*1* ? null : ???*4*)), ( | null["memoizedState"]["deps"] @@ -18905,7 +22927,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* a ⚠️ circular variable reference -3119 -> 3124 conditional = ((null !== (???*0* | ???*1*)) | false | true) +3761 -> 3766 conditional = ((null !== (???*0* | ???*1*)) | false | true) - *0* arguments[3] ⚠️ function calls are not analysed yet - *1* (???*2* ? null : ???*5*) @@ -18919,7 +22941,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* d ⚠️ circular variable reference -3124 -> 3126 call = (...) => a( +3766 -> 3768 call = (...) => a( ???*0*, ???*1*, ( @@ -18981,7 +23003,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* d ⚠️ circular variable reference -0 -> 3129 call = (...) => a( +3766 -> 3769 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3772 call = (...) => a( ???*0*, ???*1*, ( @@ -19043,43 +23069,59 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *21* d ⚠️ circular variable reference -0 -> 3130 call = (...) => undefined(8390656, 8, ???*0*, ???*1*) +0 -> 3773 call = (...) => undefined(8390656, 8, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3131 call = (...) => (undefined | FreeVar(undefined))(2048, 8, ???*0*, ???*1*) +0 -> 3774 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3775 call = (...) => (undefined | FreeVar(undefined))(2048, 8, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3132 call = (...) => (undefined | FreeVar(undefined))(4, 2, ???*0*, ???*1*) +0 -> 3776 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3777 call = (...) => (undefined | FreeVar(undefined))(4, 2, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3133 call = (...) => (undefined | FreeVar(undefined))(4, 4, ???*0*, ???*1*) +0 -> 3778 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3779 call = (...) => (undefined | FreeVar(undefined))(4, 4, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3134 conditional = ("function" === ???*0*) +0 -> 3780 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3781 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* arguments[1] ⚠️ function calls are not analysed yet -3134 -> 3135 call = (???*0* | ???*1*())() +3781 -> 3782 call = (???*0* | ???*1*())() - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a ⚠️ circular variable reference -3134 -> 3136 call = ???*0*((???*1* | ???*2*())) +3781 -> 3783 call = ???*0*((???*1* | ???*2*())) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[0] @@ -19087,11 +23129,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* a ⚠️ circular variable reference -3134 -> 3137 call = ???*0*(null) +3781 -> 3784 call = ???*0*(null) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3138 conditional = ((null !== ???*0*) | (???*1* !== ???*2*)) +3781 -> 3785 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3781 -> 3786 conditional = ((null !== ???*0*) | (???*1* !== ???*2*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unsupported expression @@ -19099,13 +23145,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -3138 -> 3139 call = (???*0* | ???*1*())() +3786 -> 3787 call = (???*0* | ???*1*())() - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a ⚠️ circular variable reference -0 -> 3142 conditional = ((null !== (???*0* | ???*1*)) | (???*6* !== (???*7* | ???*8*))) +3786 -> 3790 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3791 conditional = ((null !== (???*0* | ???*1*)) | (???*6* !== (???*7* | ???*8*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* (???*2* ? ???*4* : null) @@ -19133,7 +23183,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* c ⚠️ circular variable reference -3142 -> 3144 member call = (???*0* | (???*1* ? ???*3* : null))["concat"]([???*5*]) +3791 -> 3793 member call = (???*0* | (???*1* ? ???*3* : null))["concat"]([???*5*]) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* (null !== ???*2*) @@ -19147,7 +23197,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3146 member call = (...) => (undefined | ???*0*)["bind"](null, ???*1*, ???*2*) +0 -> 3795 member call = (...) => (undefined | ???*0*)["bind"](null, ???*1*, ???*2*) - *0* *anonymous function 69020* ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -19156,7 +23206,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3147 call = (...) => (undefined | FreeVar(undefined))( +0 -> 3796 call = (...) => (undefined | FreeVar(undefined))( 4, 4, (...) => (undefined | ???*0*)["bind"](null, ???*1*, ???*2*), @@ -19180,9 +23230,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* c ⚠️ circular variable reference -0 -> 3148 call = (...) => P() +0 -> 3797 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3798 call = (...) => P() -0 -> 3149 conditional = (???*0* === (???*1* | ???*2*)) +0 -> 3799 conditional = (???*0* === (???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -19198,7 +23252,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* b ⚠️ circular variable reference -0 -> 3152 call = (...) => (!(1) | !(0))((???*0* | (???*1* ? null : ???*4*)), ???*5*) +0 -> 3802 call = (...) => (!(1) | !(0))((???*0* | (???*1* ? null : ???*4*)), ???*5*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* (???*2* === ???*3*) @@ -19212,13 +23266,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3153 conditional = ???*0* +0 -> 3803 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3156 call = (...) => P() +3803 -> 3805 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3803 -> 3807 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3808 call = (...) => P() -0 -> 3157 conditional = (???*0* === (???*1* | ???*2*)) +0 -> 3809 conditional = (???*0* === (???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -19234,7 +23296,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* b ⚠️ circular variable reference -0 -> 3160 call = (...) => (!(1) | !(0))((???*0* | (???*1* ? null : ???*4*)), ???*5*) +0 -> 3812 call = (...) => (!(1) | !(0))((???*0* | (???*1* ? null : ???*4*)), ???*5*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* (???*2* === ???*3*) @@ -19248,21 +23310,33 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3161 conditional = ???*0* +0 -> 3813 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3163 call = (???*0* | ???*1*())() +3813 -> 3815 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3813 -> 3816 call = (???*0* | ???*1*())() - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a ⚠️ circular variable reference -0 -> 3165 conditional = (0 === ???*0*) +3813 -> 3818 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3819 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 3169 call = (???*0* ? ???*4* : (...) => ???*6*)((???*9* | 64 | ???*10*), ???*11*) +3819 -> 3823 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3819 -> 3824 call = (???*0* ? ???*4* : (...) => ???*6*)((???*9* | 64 | ???*10*), ???*11*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -19292,9 +23366,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3170 call = (...) => a() +3819 -> 3825 call = (...) => a() + +3819 -> 3828 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3173 conditional = ((0 !== (0 | 1 | ???*0* | 4 | ???*1* | ???*6*)) | ???*7*) +0 -> 3829 conditional = ((0 !== (0 | 1 | ???*0* | 4 | ???*1* | ???*6*)) | ???*7*) - *0* C ⚠️ circular variable reference - *1* ((???*2* | ???*4*) ? ???*5* : 4) @@ -19312,21 +23390,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported expression ⚠️ This value might have side effects -0 -> 3174 call = ???*0*(true) +0 -> 3830 call = ???*0*(true) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3177 call = ???*0*(false) +0 -> 3833 call = ???*0*(false) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3178 call = ???*0*() +0 -> 3834 call = ???*0*() - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3181 call = (...) => P() +0 -> 3837 call = (...) => P() + +0 -> 3838 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3182 call = (...) => (1 | ???*0* | ???*1* | a)(???*2*) +0 -> 3839 call = (...) => (1 | ???*0* | ???*1* | a)(???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* Ck @@ -19335,11 +23417,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3183 call = (...) => ((a === N) || ((null !== b) && (b === N)))(???*0*) +0 -> 3840 call = (...) => ((a === N) || ((null !== b) && (b === N)))(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3184 conditional = ( +0 -> 3841 conditional = ( | (???*0* === (null | ???*1* | ???*2*)) | (null !== ???*19*) | (???*21* === (null | ???*23* | ???*24*)) @@ -19451,7 +23533,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *40* O ⚠️ circular variable reference -3184 -> 3185 call = (...) => undefined( +3841 -> 3842 call = (...) => undefined( ???*0*, ( | ???*1* @@ -19549,7 +23631,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *33* arguments[0] ⚠️ function calls are not analysed yet -3184 -> 3186 call = (...) => Zg(a, d)( +3841 -> 3843 call = (...) => Zg(a, d)( ???*0*, ???*1*, ( @@ -19714,7 +23796,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *58* a ⚠️ circular variable reference -3184 -> 3187 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +3841 -> 3844 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -19722,7 +23804,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -3184 -> 3188 call = (...) => undefined( +3841 -> 3845 call = (...) => undefined( ( | ???*0* | { @@ -19907,7 +23989,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *68* unsupported expression ⚠️ This value might have side effects -3184 -> 3189 call = (...) => undefined( +3841 -> 3846 call = (...) => undefined( ( | ???*0* | { @@ -20069,7 +24151,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *57* a ⚠️ circular variable reference -0 -> 3190 call = (...) => (1 | ???*0* | ???*1* | a)(???*2*) +0 -> 3847 call = (...) => (1 | ???*0* | ???*1* | a)(???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* Ck @@ -20078,11 +24160,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3191 call = (...) => ((a === N) || ((null !== b) && (b === N)))(???*0*) +0 -> 3848 call = (...) => ((a === N) || ((null !== b) && (b === N)))(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3192 conditional = ( +0 -> 3849 conditional = ( | (???*0* === (null | ???*1* | ???*2*)) | (null !== ???*19*) | (???*21* === (null | ???*23* | ???*24*)) @@ -20194,7 +24276,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *40* O ⚠️ circular variable reference -3192 -> 3193 call = (...) => undefined( +3849 -> 3850 call = (...) => undefined( ???*0*, ( | { @@ -20311,7 +24393,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *43* unsupported expression ⚠️ This value might have side effects -3192 -> 3198 conditional = ((0 === ???*0*) | (null === ???*2*) | ???*4*) +3849 -> 3855 conditional = ((0 === ???*0*) | (null === ???*2*) | ???*4*) - *0* ???*1*["lanes"] ⚠️ unknown object - *1* arguments[0] @@ -20324,7 +24406,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -3198 -> 3200 call = ???*0*(???*2*, (???*4* | (???*5* ? ???*9* : null))) +3855 -> 3857 call = ???*0*(???*2*, (???*4* | (???*5* ? ???*9* : null))) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] @@ -20350,7 +24432,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* arguments[0] ⚠️ function calls are not analysed yet -3198 -> 3203 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*12*) +3855 -> 3860 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*12*) - *0* ("function" === ???*1*) ⚠️ nested operation - *1* typeof(???*2*) @@ -20384,7 +24466,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* arguments[1] ⚠️ function calls are not analysed yet -3198 -> 3204 conditional = ???*0* +3855 -> 3861 conditional = ???*0* - *0* ???*1*(???*10*, ???*13*) ⚠️ unknown callee - *1* (???*2* ? ???*5* : (...) => ???*7*) @@ -20419,17 +24501,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* arguments[1] ⚠️ function calls are not analysed yet -3204 -> 3206 conditional = (null === ???*0*) +3861 -> 3863 conditional = (null === ???*0*) - *0* ???*1*["interleaved"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -3206 -> 3208 call = (...) => undefined(???*0*) +3863 -> 3865 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -3192 -> 3213 call = (...) => Zg(a, d)( +3861 -> 3870 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +3849 -> 3871 call = (...) => Zg(a, d)( ???*0*, ???*1*, ( @@ -20613,7 +24699,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *68* a ⚠️ circular variable reference -3192 -> 3214 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +3849 -> 3872 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -20621,7 +24707,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -3192 -> 3215 call = (...) => undefined( +3849 -> 3873 call = (...) => undefined( (???*0* | (???*1* ? ???*5* : null)), ???*8*, ( @@ -20819,7 +24905,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *75* unsupported expression ⚠️ This value might have side effects -3192 -> 3216 call = (...) => undefined( +3849 -> 3874 call = (...) => undefined( (???*0* | (???*1* ? ???*5* : null)), ???*8*, ( @@ -20906,17 +24992,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *32* a ⚠️ circular variable reference -0 -> 3219 conditional = (null === ???*0*) +0 -> 3876 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3878 conditional = (null === ???*0*) - *0* ???*1*["pending"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3225 conditional = (0 !== ???*0*) +0 -> 3884 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3225 -> 3229 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +3884 -> 3888 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -20924,15 +25014,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported assign operation ⚠️ This value might have side effects -0 -> 3231 call = (...) => P() +0 -> 3890 call = (...) => P() -0 -> 3232 conditional = (???*0* === ???*1*) +0 -> 3891 conditional = (???*0* === ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3233 conditional = ((null !== (???*0* | ???*1*)) | (???*6* !== (???*7* | ???*8*))) +0 -> 3892 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3893 conditional = ((null !== (???*0* | ???*1*)) | (???*6* !== (???*7* | ???*8*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* (???*2* ? ???*4* : null) @@ -20960,7 +25054,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* c ⚠️ circular variable reference -3233 -> 3235 member call = (???*0* | (???*1* ? ???*3* : null))["concat"]([???*5*]) +3893 -> 3895 member call = (???*0* | (???*1* ? ???*3* : null))["concat"]([???*5*]) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* (null !== ???*2*) @@ -20974,7 +25068,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3237 member call = (...) => (undefined | ???*0*)["bind"](null, ???*1*, ???*2*) +0 -> 3897 member call = (...) => (undefined | ???*0*)["bind"](null, ???*1*, ???*2*) - *0* *anonymous function 69020* ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -20983,7 +25077,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3238 call = (...) => undefined( +0 -> 3898 call = (...) => undefined( 4194308, 4, (...) => (undefined | ???*0*)["bind"](null, ???*1*, ???*2*), @@ -21007,21 +25101,33 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* c ⚠️ circular variable reference -0 -> 3239 call = (...) => undefined(4194308, 4, ???*0*, ???*1*) +0 -> 3899 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3900 call = (...) => undefined(4194308, 4, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3240 call = (...) => undefined(4, 2, ???*0*, ???*1*) +0 -> 3901 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3902 call = (...) => undefined(4, 2, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3241 call = (...) => P() +0 -> 3903 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3904 call = (...) => P() -0 -> 3242 conditional = (???*0* === (???*1* | ???*2*)) +0 -> 3905 conditional = (???*0* === (???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -21037,21 +25143,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* b ⚠️ circular variable reference -0 -> 3243 call = (???*0* | ???*1*())() +0 -> 3906 call = (???*0* | ???*1*())() - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* a ⚠️ circular variable reference -0 -> 3245 call = (...) => P() +0 -> 3908 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3246 conditional = (???*0* !== ???*1*) +0 -> 3909 call = (...) => P() + +0 -> 3910 conditional = (???*0* !== ???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -3246 -> 3247 call = ???*0*((???*1* | (???*2* ? ???*5* : ???*7*))) +3910 -> 3911 call = ???*0*((???*1* | (???*2* ? ???*5* : ???*7*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -21069,7 +25179,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* b ⚠️ circular variable reference -0 -> 3253 member call = (...) => undefined["bind"]( +0 -> 3917 member call = (...) => undefined["bind"]( null, ( | null @@ -21170,23 +25280,39 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *32* unsupported expression ⚠️ This value might have side effects -0 -> 3255 call = (...) => P() +0 -> 3919 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3258 call = (...) => P() +0 -> 3920 call = (...) => P() -0 -> 3259 call = (...) => [b["memoizedState"], a](false) +0 -> 3922 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3263 member call = (...) => undefined["bind"](null, ???*0*) +0 -> 3924 call = (...) => P() + +0 -> 3925 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3926 call = (...) => [b["memoizedState"], a](false) + +0 -> 3930 member call = (...) => undefined["bind"](null, ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3265 call = (...) => P() +0 -> 3932 call = (...) => P() + +0 -> 3933 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3266 call = (...) => P() +0 -> 3934 call = (...) => P() -0 -> 3267 conditional = (false | true) +0 -> 3935 conditional = (false | true) -3267 -> 3268 conditional = (???*0* === (???*1* | ???*2*)) +3935 -> 3936 conditional = (???*0* === (???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] @@ -21196,11 +25322,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -3268 -> 3269 free var = FreeVar(Error) +3936 -> 3937 free var = FreeVar(Error) -3268 -> 3270 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(407) +3936 -> 3938 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(407) -3268 -> 3271 call = ???*0*( +3936 -> 3939 call = ???*0*( `Minified React error #${407}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -21209,7 +25335,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${407}` ⚠️ nested operation -3267 -> 3272 call = (???*0* | ???*1*() | ???*2*())() +3935 -> 3940 call = (???*0* | ???*1*() | ???*2*())() - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* c @@ -21217,11 +25343,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -3267 -> 3273 call = ???*0*() +3935 -> 3941 call = ???*0*() - *0* arguments[1] ⚠️ function calls are not analysed yet -3267 -> 3274 conditional = (null === (null | ???*0* | ???*1* | ???*4*)) +3935 -> 3942 conditional = (null === (null | ???*0* | ???*1* | ???*4*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["alternate"] @@ -21233,11 +25359,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unknown new expression ⚠️ This value might have side effects -3274 -> 3275 free var = FreeVar(Error) +3942 -> 3943 free var = FreeVar(Error) -3274 -> 3276 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(349) +3942 -> 3944 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(349) -3274 -> 3277 call = ???*0*( +3942 -> 3945 call = ???*0*( `Minified React error #${349}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -21246,7 +25372,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${349}` ⚠️ nested operation -3267 -> 3278 call = (...) => undefined( +3935 -> 3946 call = (...) => undefined( ( | null | ???*0* @@ -21324,7 +25450,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3282 member call = (...) => c(*anonymous function 67764*)["bind"]( +0 -> 3950 member call = (...) => c(*anonymous function 67764*)["bind"]( null, ( | null @@ -21405,7 +25531,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *27* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3283 call = (...) => ti(8390656, 8, a, b)( +0 -> 3951 call = (...) => ti(8390656, 8, a, b)( (...) => ???*0*["bind"]( null, (null | ???*1* | ???*2*), @@ -21477,7 +25603,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *24* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3286 member call = (...) => undefined["bind"]( +0 -> 3954 member call = (...) => undefined["bind"]( null, ( | null @@ -21565,7 +25691,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *30* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3287 call = (...) => a( +0 -> 3955 call = (...) => a( 9, (...) => undefined["bind"]( null, @@ -21644,11 +25770,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *26* unsupported expression ⚠️ This value might have side effects -0 -> 3288 call = (...) => P() +0 -> 3956 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3957 call = (...) => P() -0 -> 3290 conditional = (false | true) +0 -> 3959 conditional = (false | true) -3290 -> 3292 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) +3959 -> 3961 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) - *0* ???*1*["clz32"] ⚠️ unknown object ⚠️ This value might have side effects @@ -21668,23 +25798,31 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* max number of linking steps reached ⚠️ This value might have side effects -3290 -> 3293 member call = ???*0*["toString"](32) +3959 -> 3962 member call = ???*0*["toString"](32) - *0* unsupported expression ⚠️ This value might have side effects -3290 -> 3295 member call = ???*0*["toString"](32) +3959 -> 3964 member call = ???*0*["toString"](32) - *0* max number of linking steps reached ⚠️ This value might have side effects -3290 -> 3297 member call = ???*0*["toString"](32) +3959 -> 3966 member call = ???*0*["toString"](32) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3299 call = (...) => [b["memoizedState"], c["dispatch"]]((...) => (("function" === typeof(b)) ? b(a) : b)) +0 -> 3968 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3300 call = (...) => P() +0 -> 3969 call = (...) => [b["memoizedState"], c["dispatch"]]((...) => (("function" === typeof(b)) ? b(a) : b)) + +0 -> 3970 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3302 call = (...) => (???*0* | b)( +0 -> 3971 call = (...) => P() + +0 -> 3973 call = (...) => (???*0* | b)( ( | null | ???*2* @@ -21832,15 +25970,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *52* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3304 call = (...) => [b["memoizedState"], c["dispatch"]]((...) => (("function" === typeof(b)) ? b(a) : b)) +0 -> 3974 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3976 call = (...) => [b["memoizedState"], c["dispatch"]]((...) => (("function" === typeof(b)) ? b(a) : b)) -0 -> 3306 call = (...) => P() +0 -> 3978 call = (...) => P() -0 -> 3307 call = (...) => [f, d]((...) => (("function" === typeof(b)) ? b(a) : b)) +0 -> 3979 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 3308 call = (...) => P() +0 -> 3980 call = (...) => [f, d]((...) => (("function" === typeof(b)) ? b(a) : b)) -0 -> 3309 conditional = (null === ( +0 -> 3981 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3982 call = (...) => P() + +0 -> 3983 conditional = (null === ( | null | ???*0* | null["alternate"] @@ -21887,7 +26037,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* O ⚠️ circular variable reference -3309 -> 3312 call = (...) => (???*0* | b)( +3983 -> 3986 call = (...) => (???*0* | b)( ( | null | ???*2* @@ -22035,11 +26185,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *52* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3314 call = (...) => [f, d]((...) => (("function" === typeof(b)) ? b(a) : b)) +0 -> 3987 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3989 call = (...) => [f, d]((...) => (("function" === typeof(b)) ? b(a) : b)) -0 -> 3316 call = (...) => P() +0 -> 3991 call = (...) => P() -0 -> 3317 call = (...) => (undefined | Ma(a["type"]) | Ma("Lazy") | Ma("Suspense") | Ma("SuspenseList") | ???*0* | "")((???*1* | ???*2*)) +0 -> 3992 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3993 call = (...) => (undefined | Ma(a["type"]) | Ma("Lazy") | Ma("Suspense") | Ma("SuspenseList") | ???*0* | "")((???*1* | ???*2*)) - *0* a ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -22050,17 +26208,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* d ⚠️ circular variable reference -0 -> 3321 conditional = (null != ???*0*) +0 -> 3997 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 3998 conditional = (null != ???*0*) - *0* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3322 conditional = (null != ???*0*) +0 -> 3999 conditional = (null != ???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3324 free var = FreeVar(console) +0 -> 4000 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4002 free var = FreeVar(console) -0 -> 3326 member call = ???*0*["error"](???*1*) +0 -> 4004 member call = ???*0*["error"](???*1*) - *0* FreeVar(console) ⚠️ unknown global ⚠️ This value might have side effects @@ -22069,27 +26235,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3327 free var = FreeVar(setTimeout) +0 -> 4005 free var = FreeVar(setTimeout) -0 -> 3328 call = ???*0*((...) => undefined) +0 -> 4006 call = ???*0*((...) => undefined) - *0* FreeVar(setTimeout) ⚠️ unknown global ⚠️ This value might have side effects -0 -> 3329 free var = FreeVar(WeakMap) +0 -> 4007 free var = FreeVar(WeakMap) -0 -> 3330 conditional = ("function" === ???*0*) +0 -> 4008 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* FreeVar(WeakMap) ⚠️ unknown global ⚠️ This value might have side effects -3330 -> 3331 free var = FreeVar(WeakMap) +4008 -> 4009 free var = FreeVar(WeakMap) -3330 -> 3332 free var = FreeVar(Map) +4008 -> 4010 free var = FreeVar(Map) -0 -> 3333 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( +0 -> 4011 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( ???*0*, ( | ???*1* @@ -22105,13 +26271,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -0 -> 3338 call = (...) => undefined(???*0*, ???*1*) +0 -> 4016 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3339 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( +0 -> 4017 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4018 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( ???*0*, ( | ???*1* @@ -22127,7 +26297,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -0 -> 3343 conditional = ("function" === ???*0*) +0 -> 4022 conditional = ("function" === ???*0*) - *0* typeof(???*1*) ⚠️ nested operation - *1* ???*2*["getDerivedStateFromError"] @@ -22137,7 +26307,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -3343 -> 3346 call = ???*0*(???*3*) +4022 -> 4025 call = ???*0*(???*3*) - *0* ???*1*["getDerivedStateFromError"] ⚠️ unknown object - *1* ???*2*["type"] @@ -22149,37 +26319,41 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -3343 -> 3348 call = (...) => undefined(???*0*, ???*1*) +4022 -> 4026 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4022 -> 4028 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3352 call = (...) => undefined(???*0*, ???*1*) +0 -> 4032 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3353 conditional = (null === (???*0* | null)) +0 -> 4033 conditional = (null === (???*0* | null)) - *0* unknown new expression ⚠️ This value might have side effects -3353 -> 3354 free var = FreeVar(Set) +4033 -> 4034 free var = FreeVar(Set) -3353 -> 3356 member call = (???*0* | null)["add"](???*1*) +4033 -> 4036 member call = (???*0* | null)["add"](???*1*) - *0* unknown new expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -0 -> 3360 conditional = (null !== ???*0*) +0 -> 4040 conditional = (null !== ???*0*) - *0* ???*1*["stack"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3361 member call = ???*0*["componentDidCatch"](???*1*, {"componentStack": (???*3* ? ???*6* : "")}) +0 -> 4041 member call = ???*0*["componentDidCatch"](???*1*, {"componentStack": (???*3* ? ???*6* : "")}) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["value"] @@ -22197,7 +26371,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3363 conditional = (null === (???*0* | ???*2*)) +0 -> 4042 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4044 conditional = (null === (???*0* | ???*2*)) - *0* ???*1*["pingCache"] ⚠️ unknown object - *1* arguments[0] @@ -22205,9 +26383,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -3363 -> 3365 free var = FreeVar(Set) +4044 -> 4046 free var = FreeVar(Set) -3363 -> 3367 member call = ( +4044 -> 4048 member call = ( | ???*0* | (...) => undefined["bind"](null, ???*2*, ???*3*, ???*4*)["pingCache"] | ???*5* @@ -22260,7 +26438,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *22* arguments[1] ⚠️ function calls are not analysed yet -3363 -> 3369 member call = ( +4044 -> 4050 member call = ( | ???*0* | (...) => undefined["bind"](null, ???*2*, ???*3*, ???*4*)["pingCache"] | ???*5* @@ -22280,9 +26458,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[1] ⚠️ function calls are not analysed yet -3363 -> 3370 free var = FreeVar(Set) +4044 -> 4051 free var = FreeVar(Set) -3363 -> 3372 member call = ( +4044 -> 4053 member call = ( | ???*0* | (...) => undefined["bind"](null, ???*2*, ???*3*, ???*4*)["pingCache"] | ???*5* @@ -22335,7 +26513,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *22* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3374 member call = (???*0* | ???*1* | ???*5* | ???*13*)["has"](???*16*) +0 -> 4055 member call = (???*0* | ???*1* | ???*5* | ???*13*)["has"](???*16*) - *0* unknown new expression ⚠️ This value might have side effects - *1* ???*2*["get"](???*4*) @@ -22372,7 +26550,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3376 member call = (???*0* | ???*1* | ???*5* | ???*13*)["add"](???*16*) +0 -> 4057 member call = (???*0* | ???*1* | ???*5* | ???*13*)["add"](???*16*) - *0* unknown new expression ⚠️ This value might have side effects - *1* ???*2*["get"](???*4*) @@ -22409,7 +26587,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3378 member call = (...) => undefined["bind"]( +0 -> 4059 member call = (...) => undefined["bind"]( null, ( | ???*0* @@ -22431,7 +26609,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3380 member call = ???*0*["then"]( +0 -> 4061 member call = ???*0*["then"]( ( | ???*1* | (...) => undefined["bind"](null, ???*2*, ???*3*, ???*4*) @@ -22460,7 +26638,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3383 conditional = (null !== (???*0* | ???*1* | ???*4*)) +0 -> 4064 conditional = (null !== (???*0* | ???*1* | ???*4*)) - *0* b ⚠️ pattern without value - *1* (13 === ???*2*) @@ -22474,17 +26652,49 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[0] ⚠️ function calls are not analysed yet -3383 -> 3385 conditional = (null !== ???*0*) +4064 -> 4066 conditional = (null !== ???*0*) - *0* ???*1*["dehydrated"] ⚠️ unknown object - *1* b ⚠️ pattern without value -0 -> 3388 conditional = (0 === ???*0*) +0 -> 4067 conditional = (???*0* | (13 === ???*1*) | ???*3* | (???*5* ? ???*7* : true)) +- *0* b + ⚠️ pattern without value +- *1* ???*2*["tag"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["memoizedState"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* (null !== ???*6*) + ⚠️ nested operation +- *6* b + ⚠️ circular variable reference +- *7* (???*8* ? true : false) + ⚠️ nested operation +- *8* (null !== ???*9*) + ⚠️ nested operation +- *9* ???*10*["dehydrated"] + ⚠️ unknown object +- *10* b + ⚠️ circular variable reference + +4067 -> 4068 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4070 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4072 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3388 -> 3389 conditional = (???*0* === ( +4072 -> 4073 conditional = (???*0* === ( | ???*1* | {"eventTime": ???*2*, "lane": 1, "tag": 0, "payload": null, "callback": null, "next": null} )) @@ -22495,17 +26705,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -3389 -> 3396 conditional = (null === ???*0*) +4073 -> 4080 conditional = (null === ???*0*) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[2] ⚠️ function calls are not analysed yet -3396 -> 3398 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}(???*0*, 1) +4080 -> 4082 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}(???*0*, 1) - *0* unsupported expression ⚠️ This value might have side effects -3396 -> 3400 call = (...) => (null | Zg(a, c))( +4080 -> 4084 call = (...) => (null | Zg(a, c))( ???*0*, ( | ???*1* @@ -22520,11 +26730,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -0 -> 3406 conditional = (null === ???*0*) +4072 -> 4086 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4072 -> 4089 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4092 conditional = (null === ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -3406 -> 3407 call = (...) => ( +4092 -> 4093 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -22544,7 +26762,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[3] ⚠️ function calls are not analysed yet -3406 -> 3409 call = (...) => ( +4092 -> 4095 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -22568,13 +26786,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[3] ⚠️ function calls are not analysed yet -0 -> 3412 call = (...) => undefined(???*0*, ???*1*) +0 -> 4098 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3413 call = (...) => a(???*0*, ???*1*, (???*2* | ???*3* | (0 !== (0 | ???*5*))), (???*6* | ???*7*), ???*12*, ???*14*) +0 -> 4099 call = (...) => a(???*0*, ???*1*, (???*2* | ???*3* | (0 !== (0 | ???*5*))), (???*6* | ???*7*), ???*12*, ???*14*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -22606,9 +26824,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3414 call = (...) => a() +0 -> 4100 call = (...) => a() -0 -> 3415 conditional = ((null !== ???*0*) | !((true | false | ???*1*))) +0 -> 4101 conditional = ((null !== ???*0*) | !((true | false | ???*1*))) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* (???*2* ? true : false) @@ -22618,7 +26836,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -3415 -> 3420 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +4101 -> 4106 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -22626,11 +26844,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3421 call = (...) => undefined(???*0*) +4101 -> 4107 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4101 -> 4108 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3423 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*), ???*8*) +4101 -> 4110 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*), ???*8*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -22650,7 +26872,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3425 conditional = (null === (???*0* | ???*1* | ???*3* | ???*4* | null)) +4101 -> 4112 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4113 conditional = (null === (???*0* | ???*1* | ???*3* | ???*4* | null)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["children"] @@ -22663,7 +26889,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ sequence with side effects ⚠️ This value might have side effects -3425 -> 3427 call = (...) => !((!(a) || !(a["isReactComponent"])))( +4113 -> 4115 call = (...) => !((!(a) || !(a["isReactComponent"])))( ( | ???*0* | (???*2* ? ???*4* : (...) => (???*5* | ???*6*))["type"] @@ -22691,11 +26917,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* unknown new expression ⚠️ This value might have side effects -3425 -> 3431 conditional = ???*0* +4113 -> 4119 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3431 -> 3434 call = (...) => (???*0* | dj(a, b, c, d, e))( +4119 -> 4122 call = (...) => (???*0* | dj(a, b, c, d, e))( ( | ???*1* | ???*2* @@ -22764,7 +26990,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *22* arguments[4] ⚠️ function calls are not analysed yet -3425 -> 3437 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)( +4119 -> 4123 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4119 -> 4126 call = (...) => (Ah(c["children"], e, f, b) | ???*0* | qj(c, e, f, b) | b)( ( | ???*1* | (???*3* ? ???*5* : (...) => (???*6* | ???*7*))["type"] @@ -22803,11 +27033,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3444 conditional = (0 === ???*0*) +4119 -> 4131 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4113 -> 4134 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3444 -> 3447 conditional = (null !== (???*0* | ???*1* | ???*3*)) +4134 -> 4137 conditional = (null !== (???*0* | ???*1* | ???*3*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["compare"] @@ -22827,7 +27061,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* !(1) ⚠️ nested operation -3444 -> 3448 call = (???*0* | ???*1* | (???*3* ? ???*5* : (...) => (???*6* | ???*7*)))( +4134 -> 4138 call = (???*0* | ???*1* | (???*3* ? ???*5* : (...) => (???*6* | ???*7*)))( ( | ???*8* | (???*11* ? ???*13* : (...) => (???*14* | ???*15*))["type"]["memoizedProps"] @@ -22879,7 +27113,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* arguments[3] ⚠️ function calls are not analysed yet -3444 -> 3451 conditional = (???*0* | ((???*9* | ???*11* | null["ref"]) === ???*13*)) +4134 -> 4141 conditional = (???*0* | ((???*9* | ???*11* | null["ref"]) === ???*13*)) - *0* (???*1* | ???*2* | (???*4* ? ???*6* : (...) => (???*7* | ???*8*)))(g, d) ⚠️ non-function callee - *1* arguments[2] @@ -22912,7 +27146,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* arguments[1] ⚠️ function calls are not analysed yet -3451 -> 3452 call = (...) => (null | b["child"])( +4141 -> 4142 call = (...) => (null | b["child"])( ( | ???*0* | ???*1* @@ -22950,7 +27184,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3454 call = (...) => c( +4141 -> 4143 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4113 -> 4145 call = (...) => c( ( | ???*0* | (???*2* ? ???*4* : (...) => (???*5* | ???*6*))["type"] @@ -22981,11 +27219,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[3] ⚠️ function calls are not analysed yet -0 -> 3459 conditional = (null !== ???*0*) +4113 -> 4150 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4151 conditional = (null !== ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -3459 -> 3461 call = (...) => (!(0) | !(1))(???*0*, (???*2* | ???*3*)) +4151 -> 4153 call = (...) => (!(0) | !(1))(???*0*, (???*2* | ???*3*)) - *0* ???*1*["memoizedProps"] ⚠️ unknown object - *1* arguments[0] @@ -22997,7 +27239,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -3459 -> 3464 conditional = (true | false | (???*0* === ???*2*)) +4151 -> 4156 conditional = (true | false | (???*0* === ???*2*)) - *0* ???*1*["ref"] ⚠️ unknown object - *1* arguments[0] @@ -23007,7 +27249,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -3464 -> 3470 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +4156 -> 4162 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -23015,7 +27257,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3471 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*, (???*4* | ???*5*), ???*7*) +4156 -> 4163 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4164 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*, (???*4* | ???*5*), ???*7*) - *0* $i(a, b, e) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -23034,7 +27280,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3474 conditional = (null !== (???*0* | ???*1*)) +0 -> 4165 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4168 conditional = (null !== (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* (???*2* ? ???*8* : ???*9*) @@ -23056,7 +27306,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3477 conditional = ("hidden" === (???*0* | ???*3*)) +0 -> 4171 conditional = ("hidden" === (???*0* | ???*3*)) - *0* ???*1*["mode"] ⚠️ unknown object - *1* ???*2*["pendingProps"] @@ -23069,11 +27319,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -3477 -> 3479 conditional = (0 === ???*0*) +4171 -> 4173 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3479 -> 3481 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) +4173 -> 4175 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) - *0* unsupported assign operation ⚠️ This value might have side effects - *1* unknown mutation @@ -23083,11 +27333,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* updated with update expression ⚠️ This value might have side effects -3479 -> 3482 conditional = (0 === ???*0*) +4173 -> 4176 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3482 -> 3483 conditional = (null !== ???*0*) +4176 -> 4177 conditional = (null !== ???*0*) - *0* (???*1* ? ???*8* : null) ⚠️ nested operation - *1* (null !== (???*2* | ???*3*)) @@ -23109,7 +27359,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[0] ⚠️ function calls are not analysed yet -3482 -> 3489 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) +4176 -> 4183 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) - *0* unsupported assign operation ⚠️ This value might have side effects - *1* unknown mutation @@ -23119,7 +27369,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* updated with update expression ⚠️ This value might have side effects -3479 -> 3491 conditional = (null !== ???*0*) +4176 -> 4184 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4176 -> 4186 conditional = (null !== ???*0*) - *0* (???*1* ? ???*8* : null) ⚠️ nested operation - *1* (null !== (???*2* | ???*3*)) @@ -23141,7 +27395,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[0] ⚠️ function calls are not analysed yet -3479 -> 3493 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) +4176 -> 4188 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) - *0* unsupported assign operation ⚠️ This value might have side effects - *1* unknown mutation @@ -23151,7 +27405,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* updated with update expression ⚠️ This value might have side effects -3477 -> 3494 conditional = (null !== ???*0*) +4171 -> 4189 conditional = (null !== ???*0*) - *0* (???*1* ? ???*8* : null) ⚠️ nested operation - *1* (null !== (???*2* | ???*3*)) @@ -23173,7 +27427,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[0] ⚠️ function calls are not analysed yet -3477 -> 3497 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) +4171 -> 4192 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*1* | ???*2* | ???*3*)) - *0* unsupported assign operation ⚠️ This value might have side effects - *1* unknown mutation @@ -23183,7 +27437,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* updated with update expression ⚠️ This value might have side effects -0 -> 3498 call = (...) => undefined( +0 -> 4193 call = (...) => undefined( (???*0* | (???*1* ? ???*7* : ???*8*)), ???*9*, (???*10* | (???*13* ? ???*23* : ???*33*)["children"] | ???*34*), @@ -23265,7 +27519,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *36* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3502 conditional = ((null === ???*0*) | (null !== ???*1*) | (null !== ???*3*) | (???*4* !== ???*6*)) +0 -> 4195 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4198 conditional = ((null === ???*0*) | (null !== ???*1*) | (null !== ???*3*) | (???*4* !== ???*6*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["ref"] @@ -23283,7 +27541,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3505 call = (...) => ((null !== a) && (???*0* !== a))((???*1* | ???*2*)) +0 -> 4201 call = (...) => ((null !== a) && (???*0* !== a))((???*1* | ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] @@ -23293,7 +27551,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* c ⚠️ circular variable reference -0 -> 3506 conditional = ((null !== (???*0* | ???*1* | ???*3*)) | (???*5* !== (???*6* | ???*7* | ???*9*))) +0 -> 4202 conditional = ((null !== (???*0* | ???*1* | ???*3*)) | (???*5* !== (???*6* | ???*7* | ???*9*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*(d, e) @@ -23317,7 +27575,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* a ⚠️ circular variable reference -0 -> 3508 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)( +0 -> 4204 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)( ???*0*, ((???*1* ? ({} | ???*7*) : ({} | ???*8*)) | {} | ???*9*) ) @@ -23346,13 +27604,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3509 call = (...) => undefined(???*0*, ???*1*) +0 -> 4205 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3510 call = (...) => a( +0 -> 4206 call = (...) => a( ???*0*, ???*1*, (???*2* | ???*3*), @@ -23399,9 +27657,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3511 call = (...) => a() +0 -> 4207 call = (...) => a() -0 -> 3512 conditional = ((null !== ???*0*) | !((true | false | ???*1*))) +0 -> 4208 conditional = ((null !== ???*0*) | !((true | false | ???*1*))) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* (???*2* ? true : false) @@ -23411,7 +27669,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -3512 -> 3517 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +4208 -> 4213 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -23419,11 +27677,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3518 call = (...) => undefined(???*0*) +4208 -> 4214 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4208 -> 4215 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3520 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*), ???*5*) +4208 -> 4217 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*), ???*5*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -23437,13 +27699,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3522 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +4208 -> 4219 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4220 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3523 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== (???*4* | ???*5*))) +0 -> 4221 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== (???*4* | ???*5*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["childContextTypes"] @@ -23459,29 +27725,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -3523 -> 3524 call = (...) => !(0)(???*0*) +4221 -> 4222 call = (...) => !(0)(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3525 call = (...) => undefined(???*0*, ???*1*) +0 -> 4223 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3527 conditional = (null === ???*0*) +0 -> 4225 conditional = (null === ???*0*) - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -3527 -> 3528 call = (...) => undefined(???*0*, ???*1*) +4225 -> 4226 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -3527 -> 3529 call = (...) => b(???*0*, ???*1*, ???*2*) +4225 -> 4227 call = (...) => b(???*0*, ???*1*, ???*2*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -23489,7 +27755,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -3527 -> 3530 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +4225 -> 4228 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -23499,25 +27765,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[4] ⚠️ function calls are not analysed yet -3527 -> 3531 conditional = (null === ???*0*) +4225 -> 4229 conditional = (null === ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -3531 -> 3537 conditional = ???*0* +4229 -> 4235 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3537 -> 3538 call = (...) => b(???*0*) +4235 -> 4236 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -3537 -> 3539 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +4235 -> 4237 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -3537 -> 3540 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== (???*4* | ???*5*))) +4235 -> 4238 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== (???*4* | ???*5*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["childContextTypes"] @@ -23533,13 +27799,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -3537 -> 3542 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)(???*0*, ???*1*) +4235 -> 4240 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -3531 -> 3547 call = (...) => undefined(???*0*, ???*1*, ???*3*, ???*4*) +4229 -> 4245 call = (...) => undefined(???*0*, ???*1*, ???*3*, ???*4*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -23551,7 +27817,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -3531 -> 3550 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) +4229 -> 4248 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached @@ -23563,11 +27829,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[4] ⚠️ function calls are not analysed yet -3531 -> 3553 conditional = ???*0* +4229 -> 4251 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3553 -> 3554 call = (...) => undefined(???*0*, ???*1*, (???*2* | ("function" === ???*4*)), ???*7*) +4251 -> 4252 call = (...) => undefined(???*0*, ???*1*, (???*2* | ("function" === ???*4*)), ???*7*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -23585,7 +27851,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* max number of linking steps reached ⚠️ This value might have side effects -3553 -> 3556 call = (...) => (("function" === typeof(a["shouldComponentUpdate"])) ? a["shouldComponentUpdate"](d, f, g) : ((b["prototype"] && b["prototype"]["isPureReactComponent"]) ? (!(Ie(c, d)) || !(Ie(e, f))) : !(0)))( +4251 -> 4254 call = (...) => (("function" === typeof(a["shouldComponentUpdate"])) ? a["shouldComponentUpdate"](d, f, g) : ((b["prototype"] && b["prototype"]["isPureReactComponent"]) ? (!(Ie(c, d)) || !(Ie(e, f))) : !(0)))( ???*0*, ???*1*, ???*2*, @@ -23632,25 +27898,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* max number of linking steps reached ⚠️ This value might have side effects -3553 -> 3561 member call = ???*0*["componentWillMount"]() +4251 -> 4259 member call = ???*0*["componentWillMount"]() - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -3553 -> 3564 member call = ???*0*["UNSAFE_componentWillMount"]() +4251 -> 4262 member call = ???*0*["UNSAFE_componentWillMount"]() - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -3531 -> 3577 call = (...) => undefined(???*0*, ???*1*) +4229 -> 4275 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -3531 -> 3581 conditional = (???*0* === ???*2*) +4229 -> 4279 conditional = (???*0* === ???*2*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[1] @@ -23660,7 +27926,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -3581 -> 3583 call = (...) => b(???*0*, ???*2*) +4279 -> 4281 call = (...) => b(???*0*, ???*2*) - *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[1] @@ -23668,7 +27934,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -3531 -> 3588 conditional = ( +4229 -> 4286 conditional = ( | ("object" === ???*0*) | (null !== (???*13* | ???*16* | ???*17* | ???*18* | {})) ) @@ -23725,7 +27991,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *24* unknown mutation ⚠️ This value might have side effects -3588 -> 3589 call = (...) => b( +4286 -> 4287 call = (...) => b( (???*0* | ???*3* | ???*4* | (???*5* ? ({} | ???*9*) : ({} | ???*10*)) | {}) ) - *0* ???*1*["context"] @@ -23752,13 +28018,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* unknown mutation ⚠️ This value might have side effects -3588 -> 3590 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +4286 -> 4288 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[2] ⚠️ function calls are not analysed yet -3588 -> 3591 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== (???*4* | ???*5*))) +4286 -> 4289 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== (???*4* | ???*5*))) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["childContextTypes"] @@ -23774,7 +28040,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* a ⚠️ circular variable reference -3588 -> 3593 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)( +4286 -> 4291 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)( ???*0*, (???*1* | ???*4* | ???*5* | (???*6* ? ({} | ???*10*) : ({} | ???*11*)) | {}) ) @@ -23804,7 +28070,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* unknown mutation ⚠️ This value might have side effects -3531 -> 3598 call = (...) => undefined( +4229 -> 4296 call = (...) => undefined( ???*0*, ???*1*, ???*3*, @@ -23842,7 +28108,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* unknown mutation ⚠️ This value might have side effects -3531 -> 3601 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) +4229 -> 4299 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* max number of linking steps reached @@ -23854,11 +28120,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[4] ⚠️ function calls are not analysed yet -3531 -> 3604 conditional = ???*0* +4229 -> 4302 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3604 -> 3605 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) +4302 -> 4303 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*4*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] @@ -23870,7 +28136,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -3604 -> 3607 call = (...) => (("function" === typeof(a["shouldComponentUpdate"])) ? a["shouldComponentUpdate"](d, f, g) : ((b["prototype"] && b["prototype"]["isPureReactComponent"]) ? (!(Ie(c, d)) || !(Ie(e, f))) : !(0)))( +4302 -> 4305 call = (...) => (("function" === typeof(a["shouldComponentUpdate"])) ? a["shouldComponentUpdate"](d, f, g) : ((b["prototype"] && b["prototype"]["isPureReactComponent"]) ? (!(Ie(c, d)) || !(Ie(e, f))) : !(0)))( ???*0*, ???*1*, ???*2*, @@ -23919,7 +28185,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* unknown mutation ⚠️ This value might have side effects -3604 -> 3612 member call = ???*0*["componentWillUpdate"]( +4302 -> 4310 member call = ???*0*["componentWillUpdate"]( ???*2*, ???*3*, (???*5* | ???*8* | ???*9* | (???*10* ? ({} | ???*14*) : ({} | ???*15*)) | {}) @@ -23958,7 +28224,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* unknown mutation ⚠️ This value might have side effects -3604 -> 3615 member call = ???*0*["UNSAFE_componentWillUpdate"]( +4302 -> 4313 member call = ???*0*["UNSAFE_componentWillUpdate"]( ???*2*, ???*3*, (???*5* | ???*8* | ???*9* | (???*10* ? ({} | ???*14*) : ({} | ???*15*)) | {}) @@ -23997,7 +28263,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *15* unknown mutation ⚠️ This value might have side effects -0 -> 3641 call = (...) => ($i(a, b, f) | b["child"])(???*0*, ???*1*, ???*2*, ???*3*, (true | false), ???*4*) +0 -> 4339 call = (...) => ($i(a, b, f) | b["child"])(???*0*, ???*1*, ???*2*, ???*3*, (true | false), ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -24009,13 +28275,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3642 call = (...) => undefined(???*0*, ???*1*) +0 -> 4340 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4341 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3644 conditional = (!((???*0* | ???*1*)) | !(???*3*)) +0 -> 4343 conditional = (!((???*0* | ???*1*)) | !(???*3*)) - *0* arguments[3] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -24027,13 +28297,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -3644 -> 3645 call = (...) => undefined(???*0*, ???*1*, false) +4343 -> 4344 call = (...) => undefined(???*0*, ???*1*, false) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] ⚠️ function calls are not analysed yet -3644 -> 3646 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +4343 -> 4345 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -24041,7 +28311,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[5] ⚠️ function calls are not analysed yet -0 -> 3650 conditional = ((0 !== ???*0*) | ("function" !== ???*1*)) +4343 -> 4346 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4343 -> 4350 conditional = ((0 !== ???*0*) | ("function" !== ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects - *1* typeof(???*2*) @@ -24051,7 +28325,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -3650 -> 3652 member call = (???*0* | ???*1*)["render"]() +4350 -> 4352 member call = (???*0* | ???*1*)["render"]() - *0* arguments[3] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -24059,13 +28333,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3654 conditional = ((null !== ???*0*) | (0 !== ???*1*)) +4343 -> 4354 conditional = ((null !== ???*0*) | (0 !== ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* unsupported expression ⚠️ This value might have side effects -3654 -> 3657 call = (...) => ( +4354 -> 4357 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -24087,7 +28361,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[5] ⚠️ function calls are not analysed yet -3654 -> 3659 call = (...) => ( +4354 -> 4359 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -24115,7 +28389,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* arguments[5] ⚠️ function calls are not analysed yet -3654 -> 3660 call = (...) => undefined(???*0*, ???*1*, (???*2* ? null : ???*4*), ???*7*) +4354 -> 4360 call = (...) => undefined(???*0*, ???*1*, (???*2* ? null : ???*4*), ???*7*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -24133,13 +28407,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[5] ⚠️ function calls are not analysed yet -0 -> 3663 call = (...) => undefined(???*0*, ???*1*, true) +4343 -> 4363 call = (...) => undefined(???*0*, ???*1*, true) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3667 conditional = ???*0* +4343 -> 4365 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4368 conditional = ???*0* - *0* ???*1*["pendingContext"] ⚠️ unknown object - *1* ???*2*["stateNode"] @@ -24147,7 +28425,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -3667 -> 3671 call = (...) => undefined(???*0*, ???*1*, (???*4* !== ???*7*)) +4368 -> 4372 call = (...) => undefined(???*0*, ???*1*, (???*4* !== ???*7*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["pendingContext"] @@ -24169,7 +28447,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[0] ⚠️ function calls are not analysed yet -3667 -> 3674 call = (...) => undefined(???*0*, ???*1*, false) +4368 -> 4375 call = (...) => undefined(???*0*, ???*1*, false) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["context"] @@ -24179,7 +28457,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3676 call = (...) => undefined(???*0*, ???*1*) +0 -> 4377 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["containerInfo"] @@ -24189,13 +28467,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3677 call = (...) => undefined() +0 -> 4378 call = (...) => undefined() -0 -> 3678 call = (...) => undefined(???*0*) +0 -> 4379 call = (...) => undefined(???*0*) - *0* arguments[4] ⚠️ function calls are not analysed yet -0 -> 3680 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +0 -> 4381 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* arguments[1] @@ -24205,53 +28483,65 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[3] ⚠️ function calls are not analysed yet -0 -> 3686 conditional = ???*0* +0 -> 4383 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4384 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4389 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3687 conditional = ???*0* +0 -> 4390 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3690 call = (...) => undefined({"current": 0}, ???*0*) +0 -> 4393 call = (...) => undefined({"current": 0}, ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 3691 conditional = ???*0* +0 -> 4394 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3691 -> 3692 call = (...) => undefined(???*0*) +4394 -> 4395 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -3691 -> 3695 conditional = ???*0* +4394 -> 4398 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3695 -> 3697 conditional = (0 === ???*0*) +4398 -> 4400 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3697 -> 3700 conditional = ???*0* +4400 -> 4403 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3691 -> 3705 conditional = ???*0* +4398 -> 4406 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4398 -> 4409 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3705 -> 3708 conditional = ???*0* +4409 -> 4412 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3708 -> 3711 call = (...) => a(???*0*, ???*1*, 0, null) +4412 -> 4415 call = (...) => a(???*0*, ???*1*, 0, null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -3705 -> 3712 call = (...) => a(???*0*, ???*1*, (???*2* | ???*3*), null) +4409 -> 4416 call = (...) => a(???*0*, ???*1*, (???*2* | ???*3*), null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24263,7 +28553,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -3705 -> 3719 call = (...) => {"baseLanes": a, "cachePool": null, "transitions": null}((???*0* | ???*1*)) +4409 -> 4423 call = (...) => {"baseLanes": a, "cachePool": null, "transitions": null}((???*0* | ???*1*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["deletions"] @@ -24271,7 +28561,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -3705 -> 3721 call = (...) => ???*0*(???*1*, ???*2*) +4409 -> 4425 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -24279,11 +28569,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3724 conditional = ???*0* +4398 -> 4426 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4394 -> 4429 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3724 -> 3725 call = (...) => (???*0* | f | tj(a, b, g, null) | tj(a, b, g, d) | b)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, ???*6*, (???*7* | ???*8*)) +4429 -> 4430 call = (...) => (???*0* | f | tj(a, b, g, null) | tj(a, b, g, d) | b)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*, ???*6*, (???*7* | ???*8*)) - *0* tj(a, b, g, d) ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -24306,31 +28600,35 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3726 conditional = ???*0* +4429 -> 4431 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4429 -> 4432 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3726 -> 3733 conditional = ???*0* +4432 -> 4439 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3733 -> 3738 call = (...) => c(???*0*, ???*1*) +4439 -> 4444 call = (...) => c(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -3726 -> 3741 conditional = ???*0* +4432 -> 4447 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3741 -> 3742 call = (...) => c(???*0*, ???*1*) +4447 -> 4448 call = (...) => c(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -3741 -> 3743 call = (...) => a(???*0*, ???*1*, (???*2* | ???*3*), null) +4447 -> 4449 call = (...) => a(???*0*, ???*1*, (???*2* | ???*3*), null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24342,11 +28640,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -3726 -> 3752 conditional = ???*0* +4432 -> 4458 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3752 -> 3753 call = (...) => {"baseLanes": a, "cachePool": null, "transitions": null}((???*0* | ???*1*)) +4458 -> 4459 call = (...) => {"baseLanes": a, "cachePool": null, "transitions": null}((???*0* | ???*1*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["deletions"] @@ -24354,13 +28652,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3763 call = (...) => c(???*0*, ???*1*) +4432 -> 4466 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4432 -> 4470 call = (...) => c(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3769 conditional = (null === (???*0* | ???*1*)) +4432 -> 4476 conditional = (null === (???*0* | ???*1*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["deletions"] @@ -24368,7 +28670,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -3769 -> 3773 member call = (???*0* | ???*1*)["push"](???*3*) +4476 -> 4480 member call = (???*0* | ???*1*)["push"](???*3*) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["deletions"] @@ -24378,7 +28680,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3777 call = (...) => a( +4432 -> 4483 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4485 call = (...) => a( { "mode": "visible", "children": (???*0* | {"mode": "visible", "children": ???*1*} | ???*2*) @@ -24398,11 +28704,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3780 call = (...) => undefined(???*0*) +0 -> 4488 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4489 call = (...) => undefined(???*0*) - *0* arguments[3] ⚠️ function calls are not analysed yet -0 -> 3782 call = (...) => ( +0 -> 4491 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -24429,7 +28739,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3785 call = (...) => ???*0*(???*1*, ???*2*) +0 -> 4494 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[1] @@ -24441,15 +28751,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3788 conditional = ???*0* +0 -> 4497 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4498 conditional = ???*0* - *0* arguments[2] ⚠️ function calls are not analysed yet -3788 -> 3791 free var = FreeVar(Error) +4498 -> 4501 free var = FreeVar(Error) -3788 -> 3792 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(422) +4498 -> 4502 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(422) -3788 -> 3793 call = ???*0*( +4498 -> 4503 call = ???*0*( `Minified React error #${422}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -24458,7 +28772,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${422}` ⚠️ nested operation -3788 -> 3794 call = (...) => {"value": a, "source": null, "stack": ((null != c) ? c : null), "digest": ((null != b) ? b : null)}(???*0*) +4498 -> 4504 call = (...) => {"value": a, "source": null, "stack": ((null != c) ? c : null), "digest": ((null != b) ? b : null)}(???*0*) - *0* ???*1*(p(422)) ⚠️ unknown callee ⚠️ This value might have side effects @@ -24466,7 +28780,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -3788 -> 3795 call = (...) => a(???*0*, ???*1*, ???*2*, ???*3*) +4498 -> 4505 call = (...) => a(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24476,17 +28790,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -3788 -> 3797 conditional = ???*0* +4498 -> 4506 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4498 -> 4508 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3788 -> 3804 call = (...) => a(???*0*, ???*1*, 0, null) +4508 -> 4512 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4508 -> 4516 call = (...) => a(???*0*, ???*1*, 0, null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -3788 -> 3805 call = (...) => a(???*0*, ???*1*, ???*2*, null) +4508 -> 4517 call = (...) => a(???*0*, ???*1*, ???*2*, null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24494,7 +28816,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[6] ⚠️ function calls are not analysed yet -3788 -> 3813 call = (...) => ( +4508 -> 4525 call = (...) => ( | g(a) | ???*0* | n(a, d, f, h) @@ -24514,15 +28836,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[6] ⚠️ function calls are not analysed yet -3788 -> 3816 call = (...) => {"baseLanes": a, "cachePool": null, "transitions": null}(???*0*) +4508 -> 4528 call = (...) => {"baseLanes": a, "cachePool": null, "transitions": null}(???*0*) - *0* arguments[6] ⚠️ function calls are not analysed yet -0 -> 3819 conditional = (0 === ???*0*) +4508 -> 4530 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4498 -> 4532 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3819 -> 3820 call = (...) => a(???*0*, ???*1*, ???*2*, null) +4532 -> 4533 call = (...) => a(???*0*, ???*1*, ???*2*, null) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24530,19 +28856,23 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[6] ⚠️ function calls are not analysed yet -0 -> 3822 conditional = ???*0* +4532 -> 4534 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4532 -> 4536 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3822 -> 3826 conditional = ???*0* +4536 -> 4540 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3822 -> 3828 free var = FreeVar(Error) +4536 -> 4542 free var = FreeVar(Error) -3822 -> 3829 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(419) +4536 -> 4543 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(419) -3822 -> 3830 call = ???*0*( +4536 -> 4544 call = ???*0*( `Minified React error #${419}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -24551,7 +28881,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${419}` ⚠️ nested operation -3822 -> 3831 call = (...) => {"value": a, "source": null, "stack": ((null != c) ? c : null), "digest": ((null != b) ? b : null)}(???*0*, ???*1*, ???*2*) +4536 -> 4545 call = (...) => {"value": a, "source": null, "stack": ((null != c) ? c : null), "digest": ((null != b) ? b : null)}(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24559,7 +28889,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -3822 -> 3832 call = (...) => a(???*0*, ???*1*, ???*2*, ???*3*) +4536 -> 4546 call = (...) => a(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24569,25 +28899,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3834 conditional = ???*0* +4536 -> 4547 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4536 -> 4549 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3834 -> 3835 conditional = ???*0* +4549 -> 4550 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3835 -> 3837 conditional = (0 !== ???*0*) +4550 -> 4552 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3835 -> 3840 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) +4550 -> 4555 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -3835 -> 3841 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +4550 -> 4556 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24597,13 +28931,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -3834 -> 3842 call = (...) => undefined() +4549 -> 4557 call = (...) => undefined() -3834 -> 3843 free var = FreeVar(Error) +4549 -> 4558 free var = FreeVar(Error) -3834 -> 3844 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(421) +4549 -> 4559 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(421) -3834 -> 3845 call = ???*0*( +4549 -> 4560 call = ???*0*( `Minified React error #${421}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -24612,7 +28946,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${421}` ⚠️ nested operation -3834 -> 3846 call = (...) => {"value": a, "source": null, "stack": ((null != c) ? c : null), "digest": ((null != b) ? b : null)}(???*0*) +4549 -> 4561 call = (...) => {"value": a, "source": null, "stack": ((null != c) ? c : null), "digest": ((null != b) ? b : null)}(???*0*) - *0* ???*1*(p(421)) ⚠️ unknown callee ⚠️ This value might have side effects @@ -24620,7 +28954,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ unknown global ⚠️ This value might have side effects -3834 -> 3847 call = (...) => a(???*0*, ???*1*, ???*2*, ???*3*) +4549 -> 4562 call = (...) => a(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24630,19 +28964,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3849 conditional = ???*0* +4549 -> 4563 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4549 -> 4565 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3849 -> 3854 member call = (...) => undefined["bind"](null, ???*0*) +4565 -> 4570 member call = (...) => undefined["bind"](null, ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3858 call = (...) => (null | a)(???*0*) +4565 -> 4572 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4565 -> 4575 call = (...) => (null | a)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3865 call = (...) => ???*0*(???*1*, ???*2*) +4565 -> 4582 call = (...) => ???*0*(???*1*, ???*2*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -24650,7 +28992,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 3871 call = (...) => undefined(???*0*, ???*2*, ???*3*) +4565 -> 4584 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4589 call = (...) => undefined(???*0*, ???*2*, ???*3*) - *0* ???*1*["return"] ⚠️ unknown object - *1* arguments[0] @@ -24660,13 +29006,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[2] ⚠️ function calls are not analysed yet -0 -> 3873 conditional = (null === ???*0*) +0 -> 4591 conditional = (null === ???*0*) - *0* ???*1*["memoizedState"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3885 call = (...) => undefined( +0 -> 4603 call = (...) => undefined( ( | ???*0* | ???*1* @@ -24723,11 +29069,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* c ⚠️ circular variable reference -0 -> 3887 conditional = (0 !== ???*0*) +0 -> 4605 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3887 -> 3890 conditional = ( +4605 -> 4608 conditional = ( | (null !== ( | ???*0* | ???*1* @@ -24758,7 +29104,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* unsupported expression ⚠️ This value might have side effects -3890 -> 3893 conditional = (13 === ( +4608 -> 4611 conditional = (13 === ( | ???*0* | 0["revealOrder"]["alternate"]["tag"] | ???*2* @@ -24784,7 +29130,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -3893 -> 3895 call = (...) => undefined( +4611 -> 4613 call = (...) => undefined( ( | ???*0* | ???*1* @@ -24829,7 +29175,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[1] ⚠️ function calls are not analysed yet -3893 -> 3897 conditional = (19 === ( +4611 -> 4615 conditional = (19 === ( | ???*0* | 0["revealOrder"]["alternate"]["tag"] | ???*2* @@ -24855,7 +29201,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -3897 -> 3898 call = (...) => undefined( +4615 -> 4616 call = (...) => undefined( ( | ???*0* | ???*1* @@ -24900,7 +29246,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* arguments[1] ⚠️ function calls are not analysed yet -3897 -> 3900 conditional = (null !== ( +4615 -> 4618 conditional = (null !== ( | ???*0* | 0["revealOrder"]["alternate"]["child"] | ???*2* @@ -24926,7 +29272,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -0 -> 3912 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*2* | ???*3* | ???*4*)) +0 -> 4630 call = (...) => undefined({"current": 0}, (???*0* | 0 | ???*2* | ???*3* | ???*4*)) - *0* ???*1*["pendingProps"] ⚠️ unknown object - *1* arguments[1] @@ -24938,11 +29284,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported assign operation ⚠️ This value might have side effects -0 -> 3914 conditional = (0 === ???*0*) +0 -> 4632 conditional = (0 === ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3914 -> 3918 call = (...) => (b | null)( +4632 -> 4636 call = (...) => (b | null)( ( | ???*0* | ???*1* @@ -24970,7 +29316,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -3914 -> 3920 conditional = (null === (???*0* | ???*1* | 0["revealOrder"] | ???*3* | null | ???*5*)) +4632 -> 4638 conditional = (null === (???*0* | ???*1* | 0["revealOrder"] | ???*3* | null | ???*5*)) - *0* arguments[2] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -24985,7 +29331,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* c ⚠️ circular variable reference -3914 -> 3925 call = (...) => undefined( +4632 -> 4643 call = (...) => undefined( ???*0*, false, (???*1* | 0["revealOrder"] | ???*4* | null | ???*6* | ???*7* | null["sibling"] | null["alternate"]), @@ -25034,7 +29380,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* unknown mutation ⚠️ This value might have side effects -3914 -> 3929 call = (...) => (b | null)( +4632 -> 4647 call = (...) => (b | null)( ( | ???*0* | ???*1* @@ -25062,11 +29408,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* unknown mutation ⚠️ This value might have side effects -3914 -> 3930 conditional = ???*0* +4632 -> 4648 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -3914 -> 3934 call = (...) => undefined( +4632 -> 4652 call = (...) => undefined( ???*0*, true, (???*1* | ???*2* | 0["revealOrder"] | ???*4* | null | ???*6*), @@ -25100,13 +29446,25 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* unknown mutation ⚠️ This value might have side effects -3914 -> 3935 call = (...) => undefined(???*0*, false, null, null, ???*1*) +4632 -> 4653 call = (...) => undefined(???*0*, false, null, null, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* unsupported expression ⚠️ This value might have side effects -0 -> 3948 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== ???*5*)) +0 -> 4656 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4665 conditional = (0 === ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects + +4665 -> 4666 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4665 -> 4669 conditional = ((null !== (???*0* | ???*1*)) | (???*3* !== ???*5*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25122,11 +29480,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -3948 -> 3949 free var = FreeVar(Error) +4669 -> 4670 free var = FreeVar(Error) -3948 -> 3950 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(153) +4669 -> 4671 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(153) -3948 -> 3951 call = ???*0*( +4669 -> 4672 call = ???*0*( `Minified React error #${153}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -25135,13 +29493,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${153}` ⚠️ nested operation -0 -> 3953 conditional = (null !== ???*0*) +4665 -> 4674 conditional = (null !== ???*0*) - *0* ???*1*["child"] ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -3953 -> 3956 call = (...) => c((???*0* | ???*1*), ???*3*) +4674 -> 4677 call = (...) => c((???*0* | ???*1*), ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25153,7 +29511,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -3953 -> 3963 call = (...) => c((???*0* | ???*1*), ???*3*) +4674 -> 4684 call = (...) => c((???*0* | ???*1*), ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25165,17 +29523,21 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 3968 call = (...) => undefined(???*0*) +4665 -> 4688 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4690 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3969 call = (...) => undefined() +0 -> 4691 call = (...) => undefined() -0 -> 3970 call = (...) => undefined(???*0*) +0 -> 4692 call = (...) => undefined(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3972 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +0 -> 4694 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* ???*2*["type"] @@ -25183,11 +29545,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3973 call = (...) => !(0)(???*0*) +0 -> 4695 call = (...) => !(0)(???*0*) - *0* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3976 call = (...) => undefined(???*0*, ???*1*) +0 -> 4698 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["containerInfo"] @@ -25197,7 +29559,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 3982 call = (...) => undefined({"current": null}, (???*0* | (0 !== ???*4*)["_currentValue"])) +0 -> 4704 call = (...) => undefined({"current": null}, (???*0* | (0 !== ???*4*)["_currentValue"])) - *0* ???*1*["_currentValue"] ⚠️ unknown object - *1* ???*2*["_context"] @@ -25209,7 +29571,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -0 -> 3985 conditional = (null !== (???*0* | ???*3*)) +0 -> 4707 conditional = (null !== (???*0* | ???*3*)) - *0* ???*1*["_context"] ⚠️ unknown object - *1* ???*2*["type"] @@ -25221,7 +29583,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* unsupported expression ⚠️ This value might have side effects -3985 -> 3987 conditional = (null !== ???*0*) +4707 -> 4709 conditional = (null !== ???*0*) - *0* ???*1*["dehydrated"] ⚠️ unknown object - *1* ???*2*["_context"] @@ -25231,15 +29593,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -3987 -> 3989 call = (...) => undefined({"current": 0}, ???*0*) +4709 -> 4711 call = (...) => undefined({"current": 0}, ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3985 -> 3993 conditional = (0 !== ???*0*) +4709 -> 4713 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4709 -> 4716 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3993 -> 3994 call = (...) => (???*0* | (f ? ???*1* : rj(b, g)) | sj(a, b, g, d, h, e, c) | d)((???*2* | null | ???*3*), ???*5*, ???*6*) +4716 -> 4717 call = (...) => (???*0* | (f ? ???*1* : rj(b, g)) | sj(a, b, g, d, h, e, c) | d)((???*2* | null | ???*3*), ???*5*, ???*6*) - *0* null ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -25257,11 +29623,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[2] ⚠️ function calls are not analysed yet -3985 -> 3996 call = (...) => undefined({"current": 0}, ???*0*) +4716 -> 4718 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4716 -> 4720 call = (...) => undefined({"current": 0}, ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -3985 -> 3997 call = (...) => (null | b["child"])((???*0* | null | ???*1*), ???*3*, ???*4*) +4716 -> 4721 call = (...) => (null | b["child"])((???*0* | null | ???*1*), ???*3*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25273,7 +29643,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[2] ⚠️ function calls are not analysed yet -3985 -> 3998 conditional = (null !== (???*0* | null | ???*1*)) +4716 -> 4722 conditional = (null !== (???*0* | null | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25281,15 +29651,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 4001 call = (...) => undefined({"current": 0}, ???*0*) +4716 -> 4724 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4707 -> 4726 call = (...) => undefined({"current": 0}, ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -0 -> 4004 conditional = (0 !== ???*0*) +0 -> 4729 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -4004 -> 4005 conditional = (???*0* | (0 !== ???*3*)) +4729 -> 4730 conditional = (???*0* | (0 !== ???*3*)) - *0* ???*1*["_context"] ⚠️ unknown object - *1* ???*2*["type"] @@ -25299,7 +29673,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -4005 -> 4006 call = (...) => b["child"]((???*0* | null | ???*1*), ???*3*, ???*4*) +4730 -> 4731 call = (...) => b["child"]((???*0* | null | ???*1*), ???*3*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25311,11 +29685,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[2] ⚠️ function calls are not analysed yet -0 -> 4013 call = (...) => undefined({"current": 0}, (0 | ???*0*)) +4730 -> 4732 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4739 call = (...) => undefined({"current": 0}, (0 | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -0 -> 4015 call = (...) => (???*0* | b["child"])((???*1* | null | ???*2*), ???*4*, ???*5*) +0 -> 4740 conditional = (???*0* | (0 !== ???*3*)) +- *0* ???*1*["_context"] + ⚠️ unknown object +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* unsupported expression + ⚠️ This value might have side effects + +4740 -> 4741 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4743 call = (...) => (???*0* | b["child"])((???*1* | null | ???*2*), ???*4*, ???*5*) - *0* null ⚠️ sequence with side effects ⚠️ This value might have side effects @@ -25330,7 +29722,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[2] ⚠️ function calls are not analysed yet -0 -> 4016 call = (...) => (null | b["child"])((???*0* | null | ???*1*), ???*3*, ???*4*) +0 -> 4744 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4745 call = (...) => (null | b["child"])((???*0* | null | ???*1*), ???*3*, ???*4*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["child"] @@ -25342,7 +29738,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[2] ⚠️ function calls are not analysed yet -0 -> 4020 conditional = ((5 === ???*0*) | (6 === ???*3*)) +0 -> 4746 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4750 conditional = ((5 === ???*0*) | (6 === ???*3*)) - *0* ???*1*["tag"] ⚠️ unknown object - *1* ???*2*["child"] @@ -25356,7 +29756,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[1] ⚠️ function calls are not analysed yet -4020 -> 4023 member call = ???*0*["appendChild"](???*1*) +4750 -> 4753 member call = ???*0*["appendChild"](???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -25366,7 +29766,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* arguments[1] ⚠️ function calls are not analysed yet -4020 -> 4026 conditional = ((4 !== ???*0*) | (null !== ???*3*)) +4750 -> 4756 conditional = ((4 !== ???*0*) | (null !== ???*3*)) - *0* ???*1*["tag"] ⚠️ unknown object - *1* ???*2*["child"] @@ -25380,7 +29780,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* arguments[1] ⚠️ function calls are not analysed yet -0 -> 4039 conditional = ((???*0* | ???*2*) !== (???*8* | ???*9*)) +0 -> 4763 conditional = ((null === ???*0*) | (???*3* === ???*6*)) +- *0* ???*1*["return"] + ⚠️ unknown object +- *1* ???*2*["child"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* ???*4*["return"] + ⚠️ unknown object +- *4* ???*5*["child"] + ⚠️ unknown object +- *5* arguments[1] + ⚠️ function calls are not analysed yet +- *6* arguments[1] + ⚠️ function calls are not analysed yet + +4763 -> 4764 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4771 conditional = ((???*0* | ???*2*) !== (???*8* | ???*9*)) - *0* ???*1*["memoizedProps"] ⚠️ unknown object - *1* arguments[0] @@ -25436,11 +29856,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *14* unsupported expression ⚠️ This value might have side effects -4039 -> 4042 call = (...) => a(({} | ???*0*)) +4771 -> 4774 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -4039 -> 4043 call = (...) => A( +4771 -> 4775 call = (...) => A( {}, b, { @@ -25491,7 +29911,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *13* unsupported expression ⚠️ This value might have side effects -4039 -> 4044 call = (...) => A( +4771 -> 4776 call = (...) => A( {}, b, { @@ -25540,7 +29960,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* unsupported expression ⚠️ This value might have side effects -4039 -> 4045 call = ???*0*({}, (???*2* | ???*4*), {"value": ???*10*}) +4771 -> 4777 call = ???*0*({}, (???*2* | ???*4*), {"value": ???*10*}) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -25578,7 +29998,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *10* unsupported expression ⚠️ This value might have side effects -4039 -> 4046 call = ???*0*({}, (???*2* | ???*3*), {"value": ???*9*}) +4771 -> 4778 call = ???*0*({}, (???*2* | ???*3*), {"value": ???*9*}) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -25614,7 +30034,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* unsupported expression ⚠️ This value might have side effects -4039 -> 4047 call = (...) => A( +4771 -> 4779 call = (...) => A( {}, b, { @@ -25662,7 +30082,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *12* unsupported expression ⚠️ This value might have side effects -4039 -> 4048 call = (...) => A( +4771 -> 4780 call = (...) => A( {}, b, { @@ -25708,7 +30128,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *11* unsupported expression ⚠️ This value might have side effects -4039 -> 4052 call = (...) => undefined( +4771 -> 4784 call = (...) => undefined( (???*0* | null | {} | ???*1* | ???*5* | (???*14* ? ???*15* : ???*17*)), (???*18* | ???*19*) ) @@ -25788,7 +30208,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *24* unsupported expression ⚠️ This value might have side effects -4039 -> 4054 member call = (???*0* | ???*1*)["hasOwnProperty"]((???*7* | null | [] | ???*8*)) +4771 -> 4786 member call = (???*0* | ???*1*)["hasOwnProperty"]((???*7* | null | [] | ???*8*)) - *0* arguments[3] ⚠️ function calls are not analysed yet - *1* ???*2*( @@ -25820,7 +30240,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* f ⚠️ circular variable reference -4039 -> 4056 member call = (???*0* | ???*2*)["hasOwnProperty"]((???*8* | null | [] | ???*9*)) +4771 -> 4788 member call = (???*0* | ???*2*)["hasOwnProperty"]((???*8* | null | [] | ???*9*)) - *0* ???*1*["memoizedProps"] ⚠️ unknown object - *1* arguments[0] @@ -25854,7 +30274,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *9* f ⚠️ circular variable reference -4039 -> 4058 conditional = (!((???*0* | ???*4*)) | ???*13* | ???*18* | (null != (???*27* | ???*32*))) +4771 -> 4790 conditional = (!((???*0* | ???*4*)) | ???*13* | ???*18* | (null != (???*27* | ???*32*))) - *0* ???*1*["hasOwnProperty"]((???*2* | null | [] | ???*3*)) ⚠️ unknown callee object - *1* arguments[3] @@ -25977,13 +30397,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *40* f ⚠️ circular variable reference -4058 -> 4059 conditional = ("style" === (???*0* | null | [] | ???*1*)) +4790 -> 4791 conditional = ("style" === (???*0* | null | [] | ???*1*)) - *0* l ⚠️ pattern without value - *1* f ⚠️ circular variable reference -4059 -> 4062 member call = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*))["hasOwnProperty"](???*42*) +4791 -> 4794 member call = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*))["hasOwnProperty"](???*42*) - *0* ???*1*[(???*3* | null | [] | ???*4*)] ⚠️ unknown object - *1* ???*2*["memoizedProps"] @@ -26109,13 +30529,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *42* g ⚠️ pattern without value -4059 -> 4065 member call = {}["hasOwnProperty"]((???*0* | null | [] | ???*1*)) +4791 -> 4797 member call = {}["hasOwnProperty"]((???*0* | null | [] | ???*1*)) - *0* l ⚠️ pattern without value - *1* f ⚠️ circular variable reference -4059 -> 4066 conditional = ???*0* +4791 -> 4798 conditional = ???*0* - *0* (???*1* | ???*2*)((???*3* | null | [] | ???*4*)) ⚠️ non-function callee - *1* FreeVar(undefined) @@ -26128,7 +30548,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* f ⚠️ circular variable reference -4066 -> 4068 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), null) +4798 -> 4800 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), null) - *0* unsupported expression ⚠️ This value might have side effects - *1* l @@ -26136,7 +30556,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* f ⚠️ circular variable reference -4039 -> 4070 conditional = (null != (???*0* | ???*2*)) +4771 -> 4802 conditional = (null != (???*0* | ???*2*)) - *0* ???*1*["memoizedProps"] ⚠️ unknown object - *1* arguments[0] @@ -26166,7 +30586,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *7* unsupported expression ⚠️ This value might have side effects -4039 -> 4073 member call = (???*0* | ???*1*)["hasOwnProperty"]((???*7* | null | [] | ???*8*)) +4771 -> 4805 member call = (???*0* | ???*1*)["hasOwnProperty"]((???*7* | null | [] | ???*8*)) - *0* arguments[3] ⚠️ function calls are not analysed yet - *1* ???*2*( @@ -26198,17 +30618,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *8* f ⚠️ circular variable reference -4039 -> 4074 conditional = ???*0* +4771 -> 4806 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4074 -> 4075 conditional = ("style" === (???*0* | null | [] | ???*1*)) +4806 -> 4807 conditional = ("style" === (???*0* | null | [] | ???*1*)) - *0* l ⚠️ pattern without value - *1* f ⚠️ circular variable reference -4075 -> 4076 conditional = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*)) +4807 -> 4808 conditional = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*)) - *0* ???*1*[(???*3* | null | [] | ???*4*)] ⚠️ unknown object - *1* ???*2*["memoizedProps"] @@ -26332,7 +30752,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *41* unsupported expression ⚠️ This value might have side effects -4076 -> 4078 member call = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*))["hasOwnProperty"](???*42*) +4808 -> 4810 member call = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*))["hasOwnProperty"](???*42*) - *0* ???*1*[(???*3* | null | [] | ???*4*)] ⚠️ unknown object - *1* ???*2*["memoizedProps"] @@ -26458,7 +30878,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *42* g ⚠️ pattern without value -4076 -> 4080 member call = (???*0* | ???*4* | (???*13* ? ???*14* : ???*16*))["hasOwnProperty"](???*17*) +4808 -> 4812 member call = (???*0* | ???*4* | (???*13* ? ???*14* : ???*16*))["hasOwnProperty"](???*17*) - *0* ???*1*[(???*2* | null | [] | ???*3*)] ⚠️ unknown object - *1* arguments[3] @@ -26509,7 +30929,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* g ⚠️ pattern without value -4076 -> 4083 member call = (???*0* | ???*4* | (???*13* ? ???*14* : ???*16*))["hasOwnProperty"](???*17*) +4808 -> 4815 member call = (???*0* | ???*4* | (???*13* ? ???*14* : ???*16*))["hasOwnProperty"](???*17*) - *0* ???*1*[(???*2* | null | [] | ???*3*)] ⚠️ unknown object - *1* arguments[3] @@ -26560,7 +30980,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *17* g ⚠️ pattern without value -4076 -> 4089 member call = (null | [] | ???*0*)["push"]( +4808 -> 4821 member call = (null | [] | ???*0*)["push"]( (???*1* | null | [] | ???*2*), (???*3* | null | {} | ???*4* | ???*8* | (???*17* ? ???*18* : ???*20*)) ) @@ -26620,13 +31040,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *20* unsupported expression ⚠️ This value might have side effects -4075 -> 4090 conditional = ("dangerouslySetInnerHTML" === (???*0* | null | [] | ???*1*)) +4807 -> 4822 conditional = ("dangerouslySetInnerHTML" === (???*0* | null | [] | ???*1*)) - *0* l ⚠️ pattern without value - *1* f ⚠️ circular variable reference -4090 -> 4091 conditional = (???*0* | ???*4* | (???*13* ? ???*14* : ???*16*)) +4822 -> 4823 conditional = (???*0* | ???*4* | (???*13* ? ???*14* : ???*16*)) - *0* ???*1*[(???*2* | null | [] | ???*3*)] ⚠️ unknown object - *1* arguments[3] @@ -26675,7 +31095,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *16* unsupported expression ⚠️ This value might have side effects -4090 -> 4093 conditional = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*)) +4822 -> 4825 conditional = (???*0* | ???*5* | (???*14* ? (???*23* | ???*28*) : ???*37*) | (???*38* ? ???*39* : ???*41*)) - *0* ???*1*[(???*3* | null | [] | ???*4*)] ⚠️ unknown object - *1* ???*2*["memoizedProps"] @@ -26799,7 +31219,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *41* unsupported expression ⚠️ This value might have side effects -4090 -> 4096 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), (???*3* | ???*7* | (???*16* ? ???*17* : ???*19*))) +4822 -> 4828 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), (???*3* | ???*7* | (???*16* ? ???*17* : ???*19*))) - *0* unsupported expression ⚠️ This value might have side effects - *1* l @@ -26854,13 +31274,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* unsupported expression ⚠️ This value might have side effects -4090 -> 4097 conditional = ("children" === (???*0* | null | [] | ???*1*)) +4822 -> 4829 conditional = ("children" === (???*0* | null | [] | ???*1*)) - *0* l ⚠️ pattern without value - *1* f ⚠️ circular variable reference -4097 -> 4099 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), (???*3* | ???*7* | (???*16* ? ???*17* : ???*19*))) +4829 -> 4831 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), (???*3* | ???*7* | (???*16* ? ???*17* : ???*19*))) - *0* unsupported expression ⚠️ This value might have side effects - *1* l @@ -26915,13 +31335,13 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* unsupported expression ⚠️ This value might have side effects -4097 -> 4101 member call = {}["hasOwnProperty"]((???*0* | null | [] | ???*1*)) +4829 -> 4833 member call = {}["hasOwnProperty"]((???*0* | null | [] | ???*1*)) - *0* l ⚠️ pattern without value - *1* f ⚠️ circular variable reference -4097 -> 4102 conditional = ???*0* +4829 -> 4834 conditional = ???*0* - *0* (???*1* | ???*2*)((???*3* | null | [] | ???*4*)) ⚠️ non-function callee - *1* FreeVar(undefined) @@ -26934,7 +31354,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* f ⚠️ circular variable reference -4102 -> 4103 call = (...) => undefined("scroll", (???*0* | ???*1*)) +4834 -> 4835 call = (...) => undefined("scroll", (???*0* | ???*1*)) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["stateNode"] @@ -26942,7 +31362,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[1] ⚠️ function calls are not analysed yet -4102 -> 4105 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), (???*3* | ???*7* | (???*16* ? ???*17* : ???*19*))) +4834 -> 4837 member call = ???*0*["push"]((???*1* | null | [] | ???*2*), (???*3* | ???*7* | (???*16* ? ???*17* : ???*19*))) - *0* unsupported expression ⚠️ This value might have side effects - *1* l @@ -26997,7 +31417,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *19* unsupported expression ⚠️ This value might have side effects -4039 -> 4107 member call = ???*0*["push"]( +4771 -> 4839 member call = ???*0*["push"]( "style", (???*1* | null | {} | ???*2* | ???*6* | (???*15* ? ???*16* : ???*18*)) ) @@ -27053,9 +31473,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *18* unsupported expression ⚠️ This value might have side effects -0 -> 4111 conditional = !((false | true)) +0 -> 4843 conditional = !((false | true)) -4111 -> 4116 conditional = (null === (null | ???*0* | ???*1*)) +4843 -> 4848 conditional = (null === (null | ???*0* | ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["tail"] @@ -27063,7 +31483,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -4111 -> 4122 conditional = (null === (null | ???*0* | ???*1*)) +4843 -> 4854 conditional = (null === (null | ???*0* | ???*1*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["tail"] @@ -27071,7 +31491,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* arguments[0] ⚠️ function calls are not analysed yet -4122 -> 4124 conditional = (???*0* | ???*1* | (null === ???*3*)) +4854 -> 4856 conditional = (???*0* | ???*1* | (null === ???*3*)) - *0* arguments[1] ⚠️ function calls are not analysed yet - *1* ???*2*["tail"] @@ -27083,7 +31503,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4133 conditional = ((null !== ???*0*) | (???*2* === ???*5*)) +0 -> 4865 conditional = ((null !== ???*0*) | (???*2* === ???*5*)) - *0* ???*1*["alternate"] ⚠️ unknown object - *1* arguments[0] @@ -27099,54 +31519,66 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *6* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4151 call = (...) => undefined(???*0*) +0 -> 4882 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4884 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4153 call = (...) => b(???*0*) +0 -> 4886 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4155 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +0 -> 4887 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4889 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4156 call = (...) => undefined() +0 -> 4890 call = (...) => undefined() -0 -> 4157 call = (...) => b(???*0*) +0 -> 4891 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4159 call = (...) => undefined() +0 -> 4892 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4894 call = (...) => undefined() -0 -> 4160 call = (...) => undefined({"current": false}) +0 -> 4895 call = (...) => undefined({"current": false}) -0 -> 4161 call = (...) => undefined({"current": {}}) +0 -> 4896 call = (...) => undefined({"current": {}}) -0 -> 4162 call = (...) => undefined() +0 -> 4897 call = (...) => undefined() -0 -> 4168 conditional = ???*0* +0 -> 4903 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4168 -> 4169 call = (...) => (!(1) | ???*0* | !(0))(???*1*) +4903 -> 4904 call = (...) => (!(1) | ???*0* | !(0))(???*1*) - *0* !(1) ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4168 -> 4170 conditional = ???*0* +4903 -> 4905 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4170 -> 4176 call = (...) => undefined((null | [???*0*])) +4905 -> 4911 call = (...) => undefined((null | [???*0*])) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4177 call = (???*0* | (...) => undefined)(???*1*, ???*2*) +0 -> 4912 call = (???*0* | (...) => undefined)(???*1*, ???*2*) - *0* Bj ⚠️ pattern without value - *1* max number of linking steps reached @@ -27154,23 +31586,27 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4178 call = (...) => b(???*0*) +0 -> 4913 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4179 call = (...) => undefined(???*0*) +0 -> 4914 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4915 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4181 call = (...) => a(({} | ???*0*)) +0 -> 4917 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -0 -> 4184 conditional = ???*0* +0 -> 4920 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4184 -> 4185 call = (???*0* | (...) => undefined)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +4920 -> 4921 call = (???*0* | (...) => undefined)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) - *0* Cj ⚠️ pattern without value - *1* max number of linking steps reached @@ -27184,19 +31620,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *5* max number of linking steps reached ⚠️ This value might have side effects -4184 -> 4190 conditional = ???*0* +4920 -> 4926 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4190 -> 4192 conditional = ???*0* +4926 -> 4928 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4192 -> 4193 free var = FreeVar(Error) +4928 -> 4929 free var = FreeVar(Error) -4192 -> 4194 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(166) +4928 -> 4930 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(166) -4192 -> 4195 call = ???*0*( +4928 -> 4931 call = ???*0*( `Minified React error #${166}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -27205,108 +31641,112 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${166}` ⚠️ nested operation -4190 -> 4196 call = (...) => b(???*0*) +4926 -> 4932 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4184 -> 4198 call = (...) => a(({} | ???*0*)) +4926 -> 4933 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +4926 -> 4935 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -4184 -> 4199 call = (...) => (!(1) | ???*0* | !(0))(???*1*) +4926 -> 4936 call = (...) => (!(1) | ???*0* | !(0))(???*1*) - *0* !(1) ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4184 -> 4200 conditional = ???*0* +4926 -> 4937 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4207 call = (...) => undefined("cancel", ???*0*) +4937 -> 4944 call = (...) => undefined("cancel", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4208 call = (...) => undefined("close", ???*0*) +4937 -> 4945 call = (...) => undefined("close", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4209 call = (...) => undefined("load", ???*0*) +4937 -> 4946 call = (...) => undefined("load", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4212 call = (...) => undefined(???*0*, ???*1*) +4937 -> 4949 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4213 call = (...) => undefined("error", ???*0*) +4937 -> 4950 call = (...) => undefined("error", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4214 call = (...) => undefined("error", ???*0*) +4937 -> 4951 call = (...) => undefined("error", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4215 call = (...) => undefined("load", ???*0*) +4937 -> 4952 call = (...) => undefined("load", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4216 call = (...) => undefined("toggle", ???*0*) +4937 -> 4953 call = (...) => undefined("toggle", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4217 call = (...) => undefined(???*0*, ???*1*) +4937 -> 4954 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4218 call = (...) => undefined("invalid", ???*0*) +4937 -> 4955 call = (...) => undefined("invalid", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4221 call = (...) => undefined("invalid", ???*0*) +4937 -> 4958 call = (...) => undefined("invalid", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4222 call = (...) => undefined(???*0*, ???*1*) +4937 -> 4959 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4223 call = (...) => undefined("invalid", ???*0*) +4937 -> 4960 call = (...) => undefined("invalid", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4224 call = (...) => undefined(???*0*, ???*1*) +4937 -> 4961 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4226 member call = ???*0*["hasOwnProperty"](???*1*) +4937 -> 4963 member call = ???*0*["hasOwnProperty"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4227 conditional = ???*0* +4937 -> 4964 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4227 -> 4229 conditional = ???*0* +4964 -> 4966 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4229 -> 4230 conditional = ???*0* +4966 -> 4967 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4230 -> 4234 call = (...) => undefined(???*0*, ???*1*, ???*2*) +4967 -> 4971 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27314,7 +31754,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -4230 -> 4238 call = (...) => undefined(???*0*, ???*1*, ???*2*) +4967 -> 4975 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27322,37 +31762,37 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -4229 -> 4240 member call = {}["hasOwnProperty"](???*0*) +4966 -> 4977 member call = {}["hasOwnProperty"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4229 -> 4241 call = (...) => undefined("scroll", ???*0*) +4966 -> 4978 call = (...) => undefined("scroll", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4242 call = (...) => undefined(???*0*) +4937 -> 4979 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4243 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, true) +4937 -> 4980 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, true) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4244 call = (...) => undefined(???*0*) +4937 -> 4981 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4245 call = (...) => undefined(???*0*) +4937 -> 4982 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4251 conditional = ???*0* +4937 -> 4988 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4253 call = (...) => ( +4937 -> 4990 call = (...) => ( | undefined | "http://www.w3.org/2000/svg" | "http://www.w3.org/1998/Math/MathML" @@ -27361,29 +31801,29 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4254 conditional = ???*0* +4937 -> 4991 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4254 -> 4255 conditional = ???*0* +4991 -> 4992 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4255 -> 4257 member call = ???*0*["createElement"]("div") +4992 -> 4994 member call = ???*0*["createElement"]("div") - *0* max number of linking steps reached ⚠️ This value might have side effects -4255 -> 4261 member call = ???*0*["removeChild"](???*1*) +4992 -> 4998 member call = ???*0*["removeChild"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4255 -> 4263 conditional = ???*0* +4992 -> 5000 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4263 -> 4266 member call = ???*0*["createElement"](???*1*, ???*2*) +5000 -> 5003 member call = ???*0*["createElement"](???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27391,17 +31831,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -4263 -> 4268 member call = ???*0*["createElement"](???*1*) +5000 -> 5005 member call = ???*0*["createElement"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4263 -> 4270 conditional = ???*0* +5000 -> 5007 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4254 -> 4276 member call = ???*0*["createElementNS"](???*1*, ???*2*) +4991 -> 5013 member call = ???*0*["createElementNS"](???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27409,7 +31849,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4279 call = (???*0* | (...) => (undefined | FreeVar(undefined)))(???*1*, ???*2*, false, false) +4937 -> 5016 call = (???*0* | (...) => (undefined | FreeVar(undefined)))(???*1*, ???*2*, false, false) - *0* Aj ⚠️ pattern without value - *1* max number of linking steps reached @@ -27417,53 +31857,53 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4281 call = (...) => (undefined | ("string" === typeof(b["is"])) | !(1) | !(0))(???*0*, ???*1*) +4937 -> 5018 call = (...) => (undefined | ("string" === typeof(b["is"])) | !(1) | !(0))(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4282 call = (...) => undefined("cancel", ???*0*) +4937 -> 5019 call = (...) => undefined("cancel", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4283 call = (...) => undefined("close", ???*0*) +4937 -> 5020 call = (...) => undefined("close", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4284 call = (...) => undefined("load", ???*0*) +4937 -> 5021 call = (...) => undefined("load", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4287 call = (...) => undefined(???*0*, ???*1*) +4937 -> 5024 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4288 call = (...) => undefined("error", ???*0*) +4937 -> 5025 call = (...) => undefined("error", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4289 call = (...) => undefined("error", ???*0*) +4937 -> 5026 call = (...) => undefined("error", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4290 call = (...) => undefined("load", ???*0*) +4937 -> 5027 call = (...) => undefined("load", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4291 call = (...) => undefined("toggle", ???*0*) +4937 -> 5028 call = (...) => undefined("toggle", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4292 call = (...) => undefined(???*0*, ???*1*) +4937 -> 5029 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4293 call = (...) => A( +4937 -> 5030 call = (...) => A( {}, b, { @@ -27484,11 +31924,11 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4294 call = (...) => undefined("invalid", ???*0*) +4937 -> 5031 call = (...) => undefined("invalid", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4297 call = ???*0*({}, ???*2*, {"value": ???*3*}) +4937 -> 5034 call = ???*0*({}, ???*2*, {"value": ???*3*}) - *0* ???*1*["assign"] ⚠️ unknown object ⚠️ This value might have side effects @@ -27500,17 +31940,17 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* unsupported expression ⚠️ This value might have side effects -4200 -> 4298 call = (...) => undefined("invalid", ???*0*) +4937 -> 5035 call = (...) => undefined("invalid", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4299 call = (...) => undefined(???*0*, ???*1*) +4937 -> 5036 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4300 call = (...) => A( +4937 -> 5037 call = (...) => A( {}, b, { @@ -27528,45 +31968,45 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4301 call = (...) => undefined("invalid", ???*0*) +4937 -> 5038 call = (...) => undefined("invalid", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4302 call = (...) => undefined(???*0*, ???*1*) +4937 -> 5039 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4304 member call = ???*0*["hasOwnProperty"](???*1*) +4937 -> 5041 member call = ???*0*["hasOwnProperty"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4305 conditional = ???*0* +4937 -> 5042 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4305 -> 4307 conditional = ???*0* +5042 -> 5044 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4307 -> 4308 call = (...) => undefined(???*0*, ???*1*) +5044 -> 5045 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4307 -> 4309 conditional = ???*0* +5044 -> 5046 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4309 -> 4310 conditional = ???*0* +5046 -> 5047 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4309 -> 4312 call = ???*0*(???*2*, ???*3*) +5046 -> 5049 call = ???*0*(???*2*, ???*3*) - *0* ???*1*(*anonymous function 13608*) ⚠️ unknown callee - *1* *anonymous function 13449* @@ -27576,39 +32016,39 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -4309 -> 4313 conditional = ???*0* +5046 -> 5050 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4313 -> 4314 conditional = ???*0* +5050 -> 5051 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4314 -> 4315 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) +5051 -> 5052 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4314 -> 4316 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) +5051 -> 5053 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4313 -> 4318 member call = {}["hasOwnProperty"](???*0*) +5050 -> 5055 member call = {}["hasOwnProperty"](???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4313 -> 4319 conditional = ???*0* +5050 -> 5056 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4319 -> 4320 call = (...) => undefined("scroll", ???*0*) +5056 -> 5057 call = (...) => undefined("scroll", ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4319 -> 4321 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +5056 -> 5058 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27618,39 +32058,39 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4322 call = (...) => undefined(???*0*) +4937 -> 5059 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4323 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, false) +4937 -> 5060 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, false) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4324 call = (...) => undefined(???*0*) +4937 -> 5061 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4325 call = (...) => undefined(???*0*) +4937 -> 5062 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4329 call = (...) => (undefined | a | "")(???*0*) +4937 -> 5066 call = (...) => (undefined | a | "")(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4330 member call = ???*0*["setAttribute"]("value", ???*1*) +4937 -> 5067 member call = ???*0*["setAttribute"]("value", ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4200 -> 4334 conditional = ???*0* +4937 -> 5071 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4334 -> 4336 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, false) +5071 -> 5073 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, false) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27658,7 +32098,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -4334 -> 4340 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, true) +5071 -> 5077 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*, ???*2*, true) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27666,15 +32106,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4348 call = (...) => b(???*0*) +0 -> 5085 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4350 conditional = ???*0* +0 -> 5086 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5088 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4350 -> 4352 call = (???*0* | (...) => undefined)(???*1*, ???*2*, ???*3*, ???*4*) +5088 -> 5090 call = (???*0* | (...) => undefined)(???*1*, ???*2*, ???*3*, ???*4*) - *0* Dj ⚠️ pattern without value - *1* max number of linking steps reached @@ -27686,15 +32130,15 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *4* max number of linking steps reached ⚠️ This value might have side effects -4350 -> 4354 conditional = ???*0* +5088 -> 5092 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4354 -> 4355 free var = FreeVar(Error) +5092 -> 5093 free var = FreeVar(Error) -4354 -> 4356 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(166) +5092 -> 5094 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(166) -4354 -> 4357 call = ???*0*( +5092 -> 5095 call = ???*0*( `Minified React error #${166}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -27703,26 +32147,26 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${166}` ⚠️ nested operation -4350 -> 4359 call = (...) => a(({} | ???*0*)) +5088 -> 5097 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -4350 -> 4361 call = (...) => a(({} | ???*0*)) +5088 -> 5099 call = (...) => a(({} | ???*0*)) - *0* unknown mutation ⚠️ This value might have side effects -4350 -> 4362 call = (...) => (!(1) | ???*0* | !(0))(???*1*) +5088 -> 5100 call = (...) => (!(1) | ???*0* | !(0))(???*1*) - *0* !(1) ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4350 -> 4363 conditional = ???*0* +5088 -> 5101 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4363 -> 4371 call = (...) => undefined(???*0*, ???*1*, (0 !== ???*2*)) +5101 -> 5109 call = (...) => undefined(???*0*, ???*1*, (0 !== ???*2*)) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27730,7 +32174,7 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -4363 -> 4376 call = (...) => undefined(???*0*, ???*1*, (0 !== ???*2*)) +5101 -> 5114 call = (...) => undefined(???*0*, ???*1*, (0 !== ???*2*)) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -27738,54 +32182,58 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -4363 -> 4380 conditional = ???*0* +5101 -> 5118 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4363 -> 4382 member call = ???*0*["createTextNode"](???*1*) +5101 -> 5120 member call = ???*0*["createTextNode"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4385 call = (...) => b(???*0*) +0 -> 5123 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4386 call = (...) => undefined({"current": 0}) +0 -> 5124 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5125 call = (...) => undefined({"current": 0}) -0 -> 4391 conditional = ???*0* +0 -> 5130 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4391 -> 4394 conditional = ???*0* +5130 -> 5133 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4394 -> 4395 call = (...) => undefined() +5133 -> 5134 call = (...) => undefined() -4394 -> 4396 call = (...) => undefined() +5133 -> 5135 call = (...) => undefined() -4394 -> 4398 call = (...) => (!(1) | ???*0* | !(0))(???*1*) +5133 -> 5137 call = (...) => (!(1) | ???*0* | !(0))(???*1*) - *0* !(1) ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -4394 -> 4400 conditional = ???*0* +5133 -> 5139 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4400 -> 4401 conditional = ???*0* +5139 -> 5140 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4401 -> 4402 free var = FreeVar(Error) +5140 -> 5141 free var = FreeVar(Error) -4401 -> 4403 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(318) +5140 -> 5142 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(318) -4401 -> 4404 call = ???*0*( +5140 -> 5143 call = ???*0*( `Minified React error #${318}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -27794,19 +32242,19 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${318}` ⚠️ nested operation -4400 -> 4406 conditional = ???*0* +5139 -> 5145 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4400 -> 4408 conditional = ???*0* +5139 -> 5147 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4408 -> 4409 free var = FreeVar(Error) +5147 -> 5148 free var = FreeVar(Error) -4408 -> 4410 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(317) +5147 -> 5149 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(317) -4408 -> 4411 call = ???*0*( +5147 -> 5150 call = ???*0*( `Minified React error #${317}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) @@ -27815,3753 +32263,3226 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *1* `https://reactjs.org/docs/error-decoder.html?invariant=${317}` ⚠️ nested operation -4400 -> 4413 call = (...) => undefined() +5139 -> 5152 call = (...) => undefined() -4394 -> 4417 call = (...) => b(???*0*) +5133 -> 5156 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4394 -> 4418 call = (...) => undefined((null | [???*0*])) +5133 -> 5157 call = (...) => undefined((null | [???*0*])) - *0* arguments[0] ⚠️ function calls are not analysed yet -4391 -> 4419 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4422 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -0 -> 4429 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4429 -> 4430 call = (...) => undefined() - -0 -> 4433 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4434 call = (...) => undefined() - -0 -> 4435 call = (???*0* | (...) => undefined)(???*1*, ???*2*) -- *0* Bj - ⚠️ pattern without value -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4438 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4439 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4442 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4443 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4445 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4446 call = (...) => undefined() - -0 -> 4447 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4448 call = (...) => undefined({"current": 0}) - -0 -> 4450 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4450 -> 4451 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4454 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4454 -> 4455 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4455 -> 4456 call = (...) => undefined(???*0*, false) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4455 -> 4458 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4458 -> 4460 call = (...) => (b | null)(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4458 -> 4461 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4461 -> 4463 call = (...) => undefined(???*0*, false) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4461 -> 4471 conditional = ???*0* +5130 -> 5158 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4471 -> 4499 conditional = ???*0* -- *0* max number of linking steps reached +5158 -> 5160 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -4461 -> 4504 call = (...) => undefined({"current": 0}, ???*0*) +0 -> 5162 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -4455 -> 4508 call = module["unstable_now"]() - -4455 -> 4510 call = (...) => undefined(???*0*, false) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4454 -> 4512 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4512 -> 4513 call = (...) => (b | null)(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4512 -> 4518 call = (...) => undefined(???*0*, true) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4512 -> 4522 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4512 -> 4523 call = module["unstable_now"]() - -4512 -> 4526 call = (...) => undefined(???*0*, false) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4454 -> 4529 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4529 -> 4534 conditional = ???*0* -- *0* max number of linking steps reached +5162 -> 5164 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 4539 conditional = ???*0* +5162 -> 5170 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4539 -> 4545 call = module["unstable_now"]() +5170 -> 5171 call = (...) => undefined() -4539 -> 4548 conditional = ???*0* +5162 -> 5174 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4539 -> 4549 call = (...) => undefined({"current": 0}, ???*0*) -- *0* max number of linking steps reached +5162 -> 5175 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 4550 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 5176 call = (...) => undefined() -0 -> 4551 call = (...) => undefined() - -0 -> 4556 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4556 -> 4557 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4556 -> 4560 call = (...) => b(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4561 free var = FreeVar(Error) - -0 -> 4563 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(156, ???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4564 call = ???*0*(???*1*) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4565 call = (...) => undefined(???*0*) -- *0* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 4568 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* ???*2*["type"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 4569 call = (...) => undefined() - -0 -> 4572 call = (...) => undefined() - -0 -> 4573 call = (...) => undefined({"current": false}) - -0 -> 4574 call = (...) => undefined({"current": {}}) - -0 -> 4575 call = (...) => undefined() - -0 -> 4577 conditional = ((0 !== ???*0*) | (0 === ???*1*)) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects - -0 -> 4579 call = (...) => undefined(???*0*) -- *0* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 4580 call = (...) => undefined({"current": 0}) - -0 -> 4583 conditional = ((null !== (???*0* | ???*1*)) | (null !== ???*3*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["flags"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* ???*4*["dehydrated"] - ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet - -4583 -> 4585 conditional = (null === ???*0*) -- *0* ???*1*["alternate"] - ⚠️ unknown object -- *1* arguments[1] - ⚠️ function calls are not analysed yet - -4585 -> 4586 free var = FreeVar(Error) - -4585 -> 4587 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(340) - -4585 -> 4588 call = ???*0*( - `Minified React error #${340}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${340}` - ⚠️ nested operation - -4583 -> 4589 call = (...) => undefined() - -0 -> 4592 call = (...) => undefined({"current": 0}) - -0 -> 4593 call = (...) => undefined() - -0 -> 4596 call = (...) => undefined(???*0*) -- *0* ???*1*["_context"] - ⚠️ unknown object -- *1* ???*2*["type"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 4597 call = (...) => undefined() - -0 -> 4598 free var = FreeVar(WeakSet) - -0 -> 4599 conditional = ("function" === ???*0*) -- *0* typeof(???*1*) - ⚠️ nested operation -- *1* FreeVar(WeakSet) - ⚠️ unknown global - ⚠️ This value might have side effects - -4599 -> 4600 free var = FreeVar(WeakSet) - -4599 -> 4601 free var = FreeVar(Set) - -0 -> 4603 conditional = (null !== ???*0*) -- *0* ???*1*["ref"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -4603 -> 4604 conditional = ("function" === ???*0*) -- *0* typeof(???*1*) - ⚠️ nested operation -- *1* ???*2*["ref"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -4604 -> 4605 call = ???*0*(null) -- *0* ???*1*["ref"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -4604 -> 4606 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* d - ⚠️ pattern without value - -0 -> 4608 call = ???*0*() -- *0* arguments[2] - ⚠️ function calls are not analysed yet - -0 -> 4609 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* d +0 -> 5177 call = (???*0* | (...) => undefined)(???*1*, ???*2*) +- *0* Bj ⚠️ pattern without value - -0 -> 4610 call = (...) => b() - -0 -> 4611 call = (...) => ( - && b - && ( - || ( - && ("input" === b) - && ( - || ("text" === a["type"]) - || ("search" === a["type"]) - || ("tel" === a["type"]) - || ("url" === a["type"]) - || ("password" === a["type"]) - ) - ) - || ("textarea" === b) - || ("true" === a["contentEditable"]) - ) -)(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4612 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4612 -> 4617 free var = FreeVar(window) - -4612 -> 4620 member call = ???*0*["getSelection"]() -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4612 -> 4622 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4622 -> 4637 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4643 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -4643 -> 4645 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4645 -> 4652 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4652 -> 4654 call = (...) => b(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -4645 -> 4655 member call = ???*0*["getSnapshotBeforeUpdate"](???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects - *2* max number of linking steps reached ⚠️ This value might have side effects -4643 -> 4660 conditional = ???*0* +0 -> 5180 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4660 -> 4666 member call = ???*0*["removeChild"](???*1*) +0 -> 5181 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -4643 -> 4667 free var = FreeVar(Error) - -4643 -> 4668 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(163) - -4643 -> 4669 call = ???*0*( - `Minified React error #${163}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${163}` - ⚠️ nested operation -0 -> 4671 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached +0 -> 5182 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *2* F - ⚠️ pattern without value -0 -> 4673 conditional = ???*0* +0 -> 5185 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 4678 conditional = (null !== (???*0* | ???*2*)) -- *0* ???*1*["updateQueue"] - ⚠️ unknown object -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* (???*3* ? ???*5* : null) - ⚠️ nested operation -- *3* (null !== ???*4*) - ⚠️ nested operation -- *4* d - ⚠️ circular variable reference -- *5* ???*6*["lastEffect"] - ⚠️ unknown object -- *6* d - ⚠️ circular variable reference - -0 -> 4680 conditional = (null !== (???*0* | ???*2*)) -- *0* ???*1*["updateQueue"] - ⚠️ unknown object -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* (???*3* ? ???*5* : null) - ⚠️ nested operation -- *3* (null !== ???*4*) - ⚠️ nested operation -- *4* d - ⚠️ circular variable reference -- *5* ???*6*["lastEffect"] - ⚠️ unknown object -- *6* d - ⚠️ circular variable reference - -4680 -> 4683 conditional = (???*0* === ???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -4683 -> 4686 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*4*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* ???*3*["destroy"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*["destroy"] - ⚠️ unknown object -- *5* ???*6*["next"] - ⚠️ unknown object -- *6* e - ⚠️ circular variable reference - -0 -> 4689 conditional = (null !== (???*0* | ???*1* | ???*3*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["updateQueue"] - ⚠️ unknown object -- *2* b - ⚠️ circular variable reference -- *3* (???*4* ? ???*6* : null) - ⚠️ nested operation -- *4* (null !== ???*5*) - ⚠️ nested operation -- *5* b - ⚠️ circular variable reference -- *6* ???*7*["lastEffect"] - ⚠️ unknown object -- *7* b - ⚠️ circular variable reference - -0 -> 4691 conditional = (null !== (???*0* | ???*1* | ???*3*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["updateQueue"] - ⚠️ unknown object -- *2* b - ⚠️ circular variable reference -- *3* (???*4* ? ???*6* : null) - ⚠️ nested operation -- *4* (null !== ???*5*) - ⚠️ nested operation -- *5* b - ⚠️ circular variable reference -- *6* ???*7*["lastEffect"] - ⚠️ unknown object -- *7* b - ⚠️ circular variable reference - -4691 -> 4694 conditional = (???*0* === ???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -4694 -> 4697 call = (???*0* | ???*2*)() -- *0* ???*1*["create"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* ???*3*["create"] - ⚠️ unknown object -- *3* ???*4*["next"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference - -0 -> 4700 conditional = (null !== ???*0*) -- *0* ???*1*["ref"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -4700 -> 4703 conditional = ("function" === ???*0*) -- *0* typeof(???*1*) - ⚠️ nested operation -- *1* ???*2*["ref"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -4703 -> 4704 call = ???*0*((???*2* | ???*3*)) -- *0* ???*1*["ref"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* a - ⚠️ circular variable reference - -0 -> 4708 call = (...) => undefined(???*0*) -- *0* ???*1*["alternate"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 4733 call = (...) => ((5 === a["tag"]) || (3 === a["tag"]) || (4 === a["tag"]))(???*0*) -- *0* ???*1*["return"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 4745 conditional = ((null === ???*0*) | (4 === ???*2*)) -- *0* ???*1*["child"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 5186 call = (...) => b(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 5187 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 4750 conditional = !(???*0*) +0 -> 5189 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 4753 conditional = ((5 === ???*0*) | (6 === ???*2*)) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 5190 call = (...) => undefined() -4753 -> 4755 conditional = (???*0* | ???*1*) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["parentNode"] - ⚠️ unknown object -- *2* arguments[2] - ⚠️ function calls are not analysed yet +0 -> 5191 call = (...) => b(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4755 -> 4757 conditional = (8 === ???*0*) -- *0* ???*1*["nodeType"] - ⚠️ unknown object -- *1* arguments[2] - ⚠️ function calls are not analysed yet +0 -> 5192 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -4757 -> 4760 member call = ???*0*["insertBefore"]((???*2* | ???*3*), (???*5* | ???*6*)) -- *0* ???*1*["parentNode"] - ⚠️ unknown object -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* a - ⚠️ circular variable reference -- *5* arguments[1] - ⚠️ function calls are not analysed yet -- *6* ???*7*["parentNode"] - ⚠️ unknown object -- *7* arguments[2] - ⚠️ function calls are not analysed yet +0 -> 5193 call = (...) => undefined({"current": 0}) -4757 -> 4762 member call = (???*0* | ???*1*)["insertBefore"]((???*3* | ???*4*), (???*6* | ???*7*)) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["_reactRootContainer"] - ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* a - ⚠️ circular variable reference -- *6* arguments[1] - ⚠️ function calls are not analysed yet -- *7* ???*8*["parentNode"] - ⚠️ unknown object -- *8* arguments[2] - ⚠️ function calls are not analysed yet +0 -> 5195 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4755 -> 4764 conditional = (8 === ???*0*) -- *0* ???*1*["nodeType"] - ⚠️ unknown object -- *1* arguments[2] - ⚠️ function calls are not analysed yet +5195 -> 5196 call = (...) => b(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4764 -> 4767 member call = (???*0* | ???*1*)["insertBefore"]((???*3* | ???*4*), (???*6* | ???*7*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["parentNode"] - ⚠️ unknown object -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* a - ⚠️ circular variable reference -- *6* arguments[2] - ⚠️ function calls are not analysed yet -- *7* ???*8*["_reactRootContainer"] - ⚠️ unknown object -- *8* c - ⚠️ circular variable reference +5195 -> 5197 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -4764 -> 4769 member call = (???*0* | ???*1*)["appendChild"]((???*3* | ???*4*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["parentNode"] - ⚠️ unknown object -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* a - ⚠️ circular variable reference +5195 -> 5200 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4753 -> 4774 conditional = ((4 !== ???*0*) | ???*2*) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* (null !== a) - ⚠️ sequence with side effects +5200 -> 5201 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -4774 -> 4775 call = (...) => undefined((???*0* | ???*1*), (???*3* | ???*4*), (???*6* | ???*7*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* arguments[1] - ⚠️ function calls are not analysed yet -- *4* ???*5*["parentNode"] - ⚠️ unknown object -- *5* arguments[2] - ⚠️ function calls are not analysed yet -- *6* arguments[2] - ⚠️ function calls are not analysed yet -- *7* ???*8*["_reactRootContainer"] - ⚠️ unknown object -- *8* c - ⚠️ circular variable reference +5201 -> 5202 call = (...) => undefined(???*0*, false) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4774 -> 4777 call = (...) => undefined((???*0* | ???*1*), (???*3* | ???*4*), (???*6* | ???*7*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* arguments[1] - ⚠️ function calls are not analysed yet -- *4* ???*5*["parentNode"] - ⚠️ unknown object -- *5* arguments[2] - ⚠️ function calls are not analysed yet -- *6* arguments[2] - ⚠️ function calls are not analysed yet -- *7* ???*8*["_reactRootContainer"] - ⚠️ unknown object -- *8* c - ⚠️ circular variable reference +5201 -> 5204 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 4780 conditional = ((5 === ???*0*) | (6 === ???*2*)) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet +5204 -> 5206 call = (...) => (b | null)(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4780 -> 4782 conditional = ???*0* -- *0* arguments[1] - ⚠️ function calls are not analysed yet +5204 -> 5207 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4782 -> 4784 member call = ???*0*["insertBefore"]((???*1* | ???*2*), ???*4*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference -- *4* arguments[1] - ⚠️ function calls are not analysed yet +5207 -> 5209 call = (...) => undefined(???*0*, false) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4782 -> 4786 member call = ???*0*["appendChild"]((???*1* | ???*2*)) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference +5207 -> 5217 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4780 -> 4788 conditional = ((4 !== ???*0*) | ???*2*) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* (null !== a) - ⚠️ sequence with side effects +5217 -> 5245 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -4788 -> 4789 call = (...) => undefined((???*0* | ???*1*), ???*3*, ???*4*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* arguments[1] - ⚠️ function calls are not analysed yet -- *4* arguments[2] - ⚠️ function calls are not analysed yet +5207 -> 5250 call = (...) => undefined({"current": 0}, ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects -4788 -> 4791 call = (...) => undefined((???*0* | ???*1*), ???*3*, ???*4*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* arguments[1] - ⚠️ function calls are not analysed yet -- *4* arguments[2] - ⚠️ function calls are not analysed yet +5207 -> 5252 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 4794 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["child"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference +5201 -> 5255 call = module["unstable_now"]() -0 -> 4797 conditional = (null | ???*0* | ("function" === ???*1*)) -- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global +5201 -> 5257 call = (...) => undefined(???*0*, false) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* typeof((null["onCommitFiberUnmount"] | ???*2*)) - ⚠️ nested operation -- *2* ???*3*["onCommitFiberUnmount"] - ⚠️ unknown object + +5200 -> 5259 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global + +5259 -> 5260 call = (...) => (b | null)(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -4797 -> 4799 member call = (null | ???*0*)["onCommitFiberUnmount"]((null | ???*1*), (???*3* | ???*4*)) -- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global +5259 -> 5265 call = (...) => undefined(???*0*, true) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* ???*2*["inject"](vl) - ⚠️ unknown callee object + +5259 -> 5269 call = (...) => b(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global + +5259 -> 5270 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *3* arguments[2] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* c - ⚠️ circular variable reference -0 -> 4801 call = (...) => undefined((???*0* | ???*1*), ???*3*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* arguments[1] - ⚠️ function calls are not analysed yet +5259 -> 5271 call = module["unstable_now"]() -0 -> 4802 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +5259 -> 5274 call = (...) => undefined(???*0*, false) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4803 conditional = (false | ???*0* | ???*1* | ???*2* | true) -- *0* Yj - ⚠️ circular variable reference -- *1* unsupported expression +5200 -> 5277 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* ???*3*["next"] - ⚠️ unknown object -- *3* e - ⚠️ circular variable reference -4803 -> 4806 conditional = ???*0* +5277 -> 5282 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4806 -> 4809 member call = ???*0*["removeChild"]((???*1* | ???*2*)) +5195 -> 5287 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* c - ⚠️ circular variable reference -4806 -> 4811 member call = ???*0*["removeChild"]((???*1* | ???*2*)) +5287 -> 5293 call = module["unstable_now"]() + +5287 -> 5296 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* c - ⚠️ circular variable reference -4803 -> 4814 member call = ???*0*["removeChild"](???*1*) +5287 -> 5297 call = (...) => undefined({"current": 0}, ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* arguments[2] - ⚠️ function calls are not analysed yet -0 -> 4815 conditional = (false | ???*0* | ???*1* | ???*2* | true) -- *0* Yj - ⚠️ circular variable reference -- *1* unsupported expression +5287 -> 5298 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *2* ???*3*["next"] - ⚠️ unknown object -- *3* e - ⚠️ circular variable reference -4815 -> 4818 conditional = ???*0* +5287 -> 5299 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4818 -> 4820 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*1* | ???*2*)) -- *0* max number of linking steps reached +5287 -> 5300 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* c - ⚠️ circular variable reference -4818 -> 4822 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*1* | ???*2*)) +0 -> 5301 call = (...) => undefined() + +0 -> 5306 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* c - ⚠️ circular variable reference -4815 -> 4823 call = (...) => undefined(???*0*) +5306 -> 5307 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4815 -> 4825 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) +5306 -> 5310 call = (...) => b(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* arguments[2] - ⚠️ function calls are not analysed yet -0 -> 4828 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) -- *0* max number of linking steps reached +0 -> 5311 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4831 conditional = ???*0* +0 -> 5312 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5313 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5314 free var = FreeVar(Error) + +0 -> 5316 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(156, ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -4831 -> 4835 conditional = (0 !== ???*0*) -- *0* unsupported expression +0 -> 5317 call = ???*0*(???*1*) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -4835 -> 4836 call = (...) => undefined( - (???*0* | ???*1*), - ???*3*, - (false["destroy"] | ???*4* | true["destroy"] | ???*6*) -) -- *0* arguments[2] +0 -> 5318 call = (...) => undefined(???*0*) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] + +0 -> 5321 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* ???*2*["type"] ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* arguments[1] +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *4* ???*5*["destroy"] - ⚠️ unknown object -- *5* e - ⚠️ circular variable reference -- *6* ???*7*["destroy"] - ⚠️ unknown object + +0 -> 5322 call = (...) => undefined() + +0 -> 5325 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *7* unsupported expression + +0 -> 5326 call = (...) => undefined() + +0 -> 5327 call = (...) => undefined({"current": false}) + +0 -> 5328 call = (...) => undefined({"current": {}}) + +0 -> 5329 call = (...) => undefined() + +0 -> 5331 conditional = ((0 !== ???*0*) | (0 === ???*1*)) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression ⚠️ This value might have side effects -4835 -> 4837 call = (...) => undefined( - (???*0* | ???*1*), - ???*3*, - (false["destroy"] | ???*4* | true["destroy"] | ???*6*) -) -- *0* arguments[2] +0 -> 5333 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5334 call = (...) => undefined(???*0*) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] + +0 -> 5335 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5336 call = (...) => undefined({"current": 0}) + +0 -> 5339 conditional = ((null !== (???*0* | ???*1*)) | (null !== ???*3*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["flags"] ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* arguments[1] +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *4* ???*5*["destroy"] +- *3* ???*4*["dehydrated"] ⚠️ unknown object -- *5* e - ⚠️ circular variable reference -- *6* ???*7*["destroy"] +- *4* arguments[0] + ⚠️ function calls are not analysed yet + +5339 -> 5341 conditional = (null === ???*0*) +- *0* ???*1*["alternate"] ⚠️ unknown object +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +5341 -> 5342 free var = FreeVar(Error) + +5341 -> 5343 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(340) + +5341 -> 5344 call = ???*0*( + `Minified React error #${340}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *7* unsupported expression +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${340}` + ⚠️ nested operation + +5339 -> 5345 call = (...) => undefined() + +0 -> 5348 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 4839 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) -- *0* max number of linking steps reached +0 -> 5349 call = (...) => undefined({"current": 0}) + +0 -> 5350 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4840 call = (...) => undefined((???*0* | ???*1*), ???*3*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] +0 -> 5351 call = (...) => undefined() + +0 -> 5352 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5355 call = (...) => undefined(???*0*) +- *0* ???*1*["_context"] ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* arguments[1] +- *1* ???*2*["type"] + ⚠️ unknown object +- *2* arguments[1] ⚠️ function calls are not analysed yet -0 -> 4843 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 5356 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -4843 -> 4849 member call = ???*0*["componentWillUnmount"]() -- *0* max number of linking steps reached +0 -> 5357 call = (...) => undefined() + +0 -> 5358 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -4843 -> 4850 call = (...) => undefined((???*0* | ???*1*), ???*3*, ???*4*) -- *0* arguments[2] +0 -> 5359 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5360 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5361 free var = FreeVar(WeakSet) + +0 -> 5362 conditional = ("function" === ???*0*) +- *0* typeof(???*1*) + ⚠️ nested operation +- *1* FreeVar(WeakSet) + ⚠️ unknown global + ⚠️ This value might have side effects + +5362 -> 5363 free var = FreeVar(WeakSet) + +5362 -> 5364 free var = FreeVar(Set) + +0 -> 5366 conditional = (null !== ???*0*) +- *0* ???*1*["ref"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] + +5366 -> 5367 conditional = ("function" === ???*0*) +- *0* typeof(???*1*) + ⚠️ nested operation +- *1* ???*2*["ref"] ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* arguments[1] +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *4* h - ⚠️ pattern without value -0 -> 4851 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +5367 -> 5368 call = ???*0*(null) +- *0* ???*1*["ref"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +5367 -> 5369 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -- *2* arguments[2] +- *2* d + ⚠️ pattern without value + +0 -> 5371 call = ???*0*() +- *0* arguments[2] ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4852 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* arguments[1] +0 -> 5372 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *2* arguments[2] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference +- *2* d + ⚠️ pattern without value + +0 -> 5373 call = (...) => b() + +0 -> 5374 call = (...) => ( + && b + && ( + || ( + && ("input" === b) + && ( + || ("text" === a["type"]) + || ("search" === a["type"]) + || ("tel" === a["type"]) + || ("url" === a["type"]) + || ("password" === a["type"]) + ) + ) + || ("textarea" === b) + || ("true" === a["contentEditable"]) + ) +)(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 4855 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +0 -> 5375 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4856 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +5375 -> 5380 free var = FreeVar(window) + +5375 -> 5383 member call = ???*0*["getSelection"]() - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4857 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +5375 -> 5385 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] - ⚠️ unknown object -- *4* c - ⚠️ circular variable reference -0 -> 4859 conditional = (null !== ???*0*) -- *0* ???*1*["updateQueue"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet +5385 -> 5400 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4859 -> 4864 member call = ???*0*["forEach"]((...) => undefined) -- *0* ???*1*["updateQueue"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 5406 conditional = (0 !== ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects -4864 -> 4866 member call = (...) => undefined["bind"](null, ???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[0] - ⚠️ function calls are not analysed yet +5406 -> 5408 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4864 -> 4868 member call = (???*0* | ???*2*)["has"](???*3*) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unsupported expression +5408 -> 5415 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[0] - ⚠️ function calls are not analysed yet -4864 -> 4870 member call = (???*0* | ???*2*)["add"](???*3*) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unsupported expression +5415 -> 5417 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[0] - ⚠️ function calls are not analysed yet -4864 -> 4872 member call = ???*0*["then"]((...) => undefined["bind"](null, ???*1*, ???*2*), (...) => undefined["bind"](null, ???*3*, ???*4*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* arguments[0] - ⚠️ function calls are not analysed yet +5408 -> 5418 member call = ???*0*["getSnapshotBeforeUpdate"](???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 4874 conditional = (null !== ???*0*) -- *0* ???*1*["deletions"] - ⚠️ unknown object -- *1* arguments[1] - ⚠️ function calls are not analysed yet +5406 -> 5423 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -4874 -> 4884 conditional = ???*0* +5423 -> 5429 member call = ???*0*["removeChild"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects -4884 -> 4885 free var = FreeVar(Error) +5406 -> 5430 free var = FreeVar(Error) -4884 -> 4886 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(160) +5406 -> 5431 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(163) -4884 -> 4887 call = ???*0*( - `Minified React error #${160}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +5406 -> 5432 call = ???*0*( + `Minified React error #${163}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${160}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${163}` ⚠️ nested operation -4874 -> 4888 call = (...) => undefined(???*0*, (???*1* | ???*2*), ???*4*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 5434 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* F + ⚠️ pattern without value + +0 -> 5436 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 5440 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 5442 conditional = (null !== (???*0* | ???*2*)) +- *0* ???*1*["updateQueue"] + ⚠️ unknown object - *1* arguments[1] ⚠️ function calls are not analysed yet -- *2* ???*3*["child"] - ⚠️ unknown object -- *3* b +- *2* (???*3* ? ???*5* : null) + ⚠️ nested operation +- *3* (null !== ???*4*) + ⚠️ nested operation +- *4* d ⚠️ circular variable reference -- *4* ???*5*[d] - ⚠️ unknown object -- *5* ???*6*["deletions"] +- *5* ???*6*["lastEffect"] ⚠️ unknown object -- *6* arguments[1] - ⚠️ function calls are not analysed yet +- *6* d + ⚠️ circular variable reference -4874 -> 4892 call = (...) => undefined(???*0*, (???*3* | ???*4*), ???*6*) -- *0* ???*1*[d] - ⚠️ unknown object -- *1* ???*2*["deletions"] +0 -> 5444 conditional = (null !== (???*0* | ???*2*)) +- *0* ???*1*["updateQueue"] ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* arguments[1] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *4* ???*5*["child"] - ⚠️ unknown object -- *5* b +- *2* (???*3* ? ???*5* : null) + ⚠️ nested operation +- *3* (null !== ???*4*) + ⚠️ nested operation +- *4* d ⚠️ circular variable reference -- *6* l - ⚠️ pattern without value - -0 -> 4895 call = (...) => undefined((???*0* | ???*1*), ???*3*) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["child"] +- *5* ???*6*["lastEffect"] ⚠️ unknown object -- *2* b +- *6* d ⚠️ circular variable reference -- *3* arguments[0] - ⚠️ function calls are not analysed yet -0 -> 4900 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +5444 -> 5447 conditional = (???*0* === ???*1*) +- *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4901 call = (...) => undefined(???*0*) -- *0* arguments[0] +5447 -> 5450 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*4*)) +- *0* arguments[1] ⚠️ function calls are not analysed yet - -0 -> 4903 call = (...) => undefined(3, ???*0*, ???*1*) -- *0* arguments[0] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +- *2* ???*3*["destroy"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 4904 call = (...) => undefined(3, ???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 4906 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] + ⚠️ This value might have side effects +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* ???*5*["destroy"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value +- *5* ???*6*["next"] + ⚠️ unknown object +- *6* e + ⚠️ circular variable reference -0 -> 4908 call = (...) => undefined(5, ???*0*, ???*1*) -- *0* arguments[0] +0 -> 5453 conditional = (null !== (???*0* | ???*1* | ???*3*)) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +- *1* ???*2*["updateQueue"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet +- *2* b + ⚠️ circular variable reference +- *3* (???*4* ? ???*6* : null) + ⚠️ nested operation +- *4* (null !== ???*5*) + ⚠️ nested operation +- *5* b + ⚠️ circular variable reference +- *6* ???*7*["lastEffect"] + ⚠️ unknown object +- *7* b + ⚠️ circular variable reference -0 -> 4910 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] +0 -> 5455 conditional = (null !== (???*0* | ???*1* | ???*3*)) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +- *1* ???*2*["updateQueue"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value +- *2* b + ⚠️ circular variable reference +- *3* (???*4* ? ???*6* : null) + ⚠️ nested operation +- *4* (null !== ???*5*) + ⚠️ nested operation +- *5* b + ⚠️ circular variable reference +- *6* ???*7*["lastEffect"] + ⚠️ unknown object +- *7* b + ⚠️ circular variable reference -0 -> 4911 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +5455 -> 5458 conditional = (???*0* === ???*1*) +- *0* unsupported expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4912 call = (...) => undefined(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 4914 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +5458 -> 5461 call = (???*0* | ???*2*)() +- *0* ???*1*["create"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *1* unsupported expression ⚠️ This value might have side effects +- *2* ???*3*["create"] + ⚠️ unknown object +- *3* ???*4*["next"] + ⚠️ unknown object +- *4* c + ⚠️ circular variable reference -0 -> 4915 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 5464 conditional = (null !== ???*0*) +- *0* ???*1*["ref"] + ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4916 call = (...) => undefined(???*0*) -- *0* arguments[0] +5464 -> 5467 conditional = ("function" === ???*0*) +- *0* typeof(???*1*) + ⚠️ nested operation +- *1* ???*2*["ref"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4918 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 4921 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), "") -- *0* ???*1*["stateNode"] +5467 -> 5468 call = ???*0*((???*2* | ???*3*)) +- *0* ???*1*["ref"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects +- *4* a + ⚠️ circular variable reference -0 -> 4923 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +0 -> 5472 call = (...) => undefined(???*0*) +- *0* ???*1*["alternate"] ⚠️ unknown object -- *2* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value - -0 -> 4925 conditional = (???*0* | ???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* (null != e) - ⚠️ sequence with side effects - ⚠️ This value might have side effects -4925 -> 4927 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 5494 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -4925 -> 4932 conditional = (null !== (???*0* | ???*2*)) -- *0* ???*1*["updateQueue"] +0 -> 5498 call = (...) => ((5 === a["tag"]) || (3 === a["tag"]) || (4 === a["tag"]))(???*0*) +- *0* ???*1*["return"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["style"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* ???*4*["memoizedProps"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *4* unsupported expression - ⚠️ This value might have side effects -4932 -> 4935 call = (...) => undefined((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) -- *0* ???*1*["stateNode"] +0 -> 5499 conditional = ((null === ???*0*) | (5 === ???*2*) | (3 === ???*5*) | (4 === ???*8*)) +- *0* ???*1*["return"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] +- *2* ???*3*["tag"] ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*["memoizedProps"] +- *3* ???*4*["return"] ⚠️ unknown object -- *5* arguments[0] +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *6* ???*7*["memoizedState"] +- *5* ???*6*["tag"] ⚠️ unknown object -- *7* ???*8*["stateNode"] +- *6* ???*7*["return"] ⚠️ unknown object -- *8* arguments[0] +- *7* arguments[0] ⚠️ function calls are not analysed yet -- *9* ???*10*["memoizedState"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *11* unsupported expression - ⚠️ This value might have side effects -- *12* ???*13*["style"] +- *8* ???*9*["tag"] ⚠️ unknown object - ⚠️ This value might have side effects -- *13* ???*14*["stateNode"] +- *9* ???*10*["return"] ⚠️ unknown object - ⚠️ This value might have side effects -- *14* unsupported expression +- *10* arguments[0] + ⚠️ function calls are not analysed yet + +5499 -> 5500 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -4932 -> 4936 call = (...) => (undefined | ("string" === typeof(b["is"])) | !(1) | !(0))((???*0* | ???*2*), ???*4*) -- *0* ???*1*["type"] +0 -> 5512 conditional = ((null === ???*0*) | (4 === ???*2*)) +- *0* ???*1*["child"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] +- *2* ???*3*["tag"] ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 5517 conditional = !(???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* max number of linking steps reached + +5517 -> 5519 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -4932 -> 4937 call = (...) => (undefined | ("string" === typeof(b["is"])) | !(1) | !(0))((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) -- *0* ???*1*["type"] +0 -> 5521 conditional = ((5 === ???*0*) | (6 === ???*2*)) +- *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] +- *2* ???*3*["tag"] ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*["memoizedProps"] +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +5521 -> 5523 conditional = (???*0* | ???*1*) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* ???*2*["parentNode"] ⚠️ unknown object -- *5* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *6* ???*7*["memoizedState"] + +5523 -> 5525 conditional = (8 === ???*0*) +- *0* ???*1*["nodeType"] ⚠️ unknown object -- *7* ???*8*["stateNode"] +- *1* arguments[2] + ⚠️ function calls are not analysed yet + +5525 -> 5528 member call = ???*0*["insertBefore"]((???*2* | ???*3*), (???*5* | ???*6*)) +- *0* ???*1*["parentNode"] ⚠️ unknown object -- *8* arguments[0] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *9* ???*10*["memoizedState"] +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] +- *4* a + ⚠️ circular variable reference +- *5* arguments[1] + ⚠️ function calls are not analysed yet +- *6* ???*7*["parentNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *11* unsupported expression - ⚠️ This value might have side effects -- *12* ???*13*["style"] +- *7* arguments[2] + ⚠️ function calls are not analysed yet + +5525 -> 5530 member call = (???*0* | ???*1*)["insertBefore"]((???*3* | ???*4*), (???*6* | ???*7*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["_reactRootContainer"] ⚠️ unknown object - ⚠️ This value might have side effects -- *13* ???*14*["stateNode"] +- *2* c + ⚠️ circular variable reference +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *14* unsupported expression - ⚠️ This value might have side effects +- *5* a + ⚠️ circular variable reference +- *6* arguments[1] + ⚠️ function calls are not analysed yet +- *7* ???*8*["parentNode"] + ⚠️ unknown object +- *8* arguments[2] + ⚠️ function calls are not analysed yet -4932 -> 4941 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +5523 -> 5532 conditional = (8 === ???*0*) +- *0* ???*1*["nodeType"] + ⚠️ unknown object +- *1* arguments[2] + ⚠️ function calls are not analysed yet -4941 -> 4942 call = (...) => undefined((???*0* | ???*2*), (???*4* | ???*7* | ???*8*)) -- *0* ???*1*["stateNode"] +5532 -> 5535 member call = (???*0* | ???*1*)["insertBefore"]((???*3* | ???*4*), (???*6* | ???*7*)) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* ???*2*["parentNode"] ⚠️ unknown object -- *1* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*[(g + 1)] +- *5* a + ⚠️ circular variable reference +- *6* arguments[2] + ⚠️ function calls are not analysed yet +- *7* ???*8*["_reactRootContainer"] ⚠️ unknown object -- *5* ???*6*["updateQueue"] +- *8* c + ⚠️ circular variable reference + +5532 -> 5537 member call = (???*0* | ???*1*)["appendChild"]((???*3* | ???*4*)) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* ???*2*["parentNode"] ⚠️ unknown object -- *6* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *7* unsupported expression - ⚠️ This value might have side effects -- *8* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet +- *4* ???*5*["stateNode"] + ⚠️ unknown object +- *5* a + ⚠️ circular variable reference -4941 -> 4943 conditional = ???*0* -- *0* max number of linking steps reached +5521 -> 5542 conditional = ((4 !== ???*0*) | ???*2*) +- *0* ???*1*["tag"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* (null !== a) + ⚠️ sequence with side effects ⚠️ This value might have side effects -4943 -> 4944 call = ???*0*((???*2* | ???*4*), (???*6* | ???*9* | ???*10*)) -- *0* ???*1*(*anonymous function 13608*) - ⚠️ unknown callee -- *1* *anonymous function 13449* - ⚠️ no value of this variable analysed -- *2* ???*3*["stateNode"] +5542 -> 5543 call = (...) => undefined((???*0* | ???*1*), (???*3* | ???*4*), (???*6* | ???*7*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object -- *3* arguments[0] +- *2* a + ⚠️ circular variable reference +- *3* arguments[1] ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] +- *4* ???*5*["parentNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *5* unsupported expression - ⚠️ This value might have side effects -- *6* ???*7*[(g + 1)] +- *5* arguments[2] + ⚠️ function calls are not analysed yet +- *6* arguments[2] + ⚠️ function calls are not analysed yet +- *7* ???*8*["_reactRootContainer"] ⚠️ unknown object -- *7* ???*8*["updateQueue"] +- *8* c + ⚠️ circular variable reference + +5542 -> 5545 call = (...) => undefined((???*0* | ???*1*), (???*3* | ???*4*), (???*6* | ???*7*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object -- *8* arguments[0] +- *2* a + ⚠️ circular variable reference +- *3* arguments[1] ⚠️ function calls are not analysed yet -- *9* unsupported expression - ⚠️ This value might have side effects -- *10* arguments[0] +- *4* ???*5*["parentNode"] + ⚠️ unknown object +- *5* arguments[2] ⚠️ function calls are not analysed yet +- *6* arguments[2] + ⚠️ function calls are not analysed yet +- *7* ???*8*["_reactRootContainer"] + ⚠️ unknown object +- *8* c + ⚠️ circular variable reference -4943 -> 4945 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4945 -> 4946 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), (???*4* | ???*7* | ???*8*)) -- *0* ???*1*["stateNode"] +0 -> 5548 conditional = ((5 === ???*0*) | (6 === ???*2*)) +- *0* ???*1*["tag"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*[(g + 1)] - ⚠️ unknown object -- *5* ???*6*["updateQueue"] +- *2* ???*3*["tag"] ⚠️ unknown object -- *6* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *7* unsupported expression - ⚠️ This value might have side effects -- *8* arguments[0] + +5548 -> 5550 conditional = ???*0* +- *0* arguments[1] ⚠️ function calls are not analysed yet -4945 -> 4947 call = (...) => undefined((???*0* | ???*2*), ???*4*, (???*5* | ???*8* | ???*9*), ???*10*) -- *0* ???*1*["stateNode"] - ⚠️ unknown object +5550 -> 5552 member call = ???*0*["insertBefore"]((???*1* | ???*2*), ???*4*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet - *2* ???*3*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects -- *5* ???*6*[(g + 1)] - ⚠️ unknown object -- *6* ???*7*["updateQueue"] - ⚠️ unknown object -- *7* arguments[0] - ⚠️ function calls are not analysed yet -- *8* unsupported expression - ⚠️ This value might have side effects -- *9* arguments[0] +- *3* a + ⚠️ circular variable reference +- *4* arguments[1] ⚠️ function calls are not analysed yet -- *10* max number of linking steps reached - ⚠️ This value might have side effects -4932 -> 4948 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) -- *0* ???*1*["stateNode"] - ⚠️ unknown object +5550 -> 5554 member call = ???*0*["appendChild"]((???*1* | ???*2*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet - *1* arguments[0] ⚠️ function calls are not analysed yet - *2* ???*3*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*["memoizedProps"] +- *3* a + ⚠️ circular variable reference + +5548 -> 5556 conditional = ((4 !== ???*0*) | ???*2*) +- *0* ???*1*["tag"] ⚠️ unknown object -- *5* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *6* ???*7*["memoizedState"] +- *2* (null !== a) + ⚠️ sequence with side effects + ⚠️ This value might have side effects + +5556 -> 5557 call = (...) => undefined((???*0* | ???*1*), ???*3*, ???*4*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object -- *7* ???*8*["stateNode"] +- *2* a + ⚠️ circular variable reference +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* arguments[2] + ⚠️ function calls are not analysed yet + +5556 -> 5559 call = (...) => undefined((???*0* | ???*1*), ???*3*, ???*4*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object -- *8* arguments[0] +- *2* a + ⚠️ circular variable reference +- *3* arguments[1] ⚠️ function calls are not analysed yet -- *9* ???*10*["memoizedState"] +- *4* arguments[2] + ⚠️ function calls are not analysed yet + +0 -> 5562 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* ???*4*["child"] ⚠️ unknown object +- *4* c + ⚠️ circular variable reference + +0 -> 5565 conditional = (null | ???*0* | ("function" === ???*1*)) +- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] +- *1* typeof((null["onCommitFiberUnmount"] | ???*2*)) + ⚠️ nested operation +- *2* ???*3*["onCommitFiberUnmount"] ⚠️ unknown object ⚠️ This value might have side effects -- *11* unsupported expression +- *3* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global ⚠️ This value might have side effects -- *12* ???*13*["style"] - ⚠️ unknown object + +5565 -> 5567 member call = (null | ???*0*)["onCommitFiberUnmount"]((null | ???*1*), (???*3* | ???*4*)) +- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global ⚠️ This value might have side effects -- *13* ???*14*["stateNode"] - ⚠️ unknown object +- *1* ???*2*["inject"](vl) + ⚠️ unknown callee object ⚠️ This value might have side effects -- *14* unsupported expression +- *2* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global ⚠️ This value might have side effects - -4932 -> 4949 call = (...) => undefined((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) -- *0* ???*1*["stateNode"] +- *3* arguments[2] + ⚠️ function calls are not analysed yet +- *4* ???*5*["stateNode"] ⚠️ unknown object -- *1* arguments[0] +- *5* c + ⚠️ circular variable reference + +0 -> 5569 call = (...) => undefined((???*0* | ???*1*), ???*3*) +- *0* arguments[2] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] +- *1* ???*2*["stateNode"] ⚠️ unknown object +- *2* c + ⚠️ circular variable reference +- *3* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 5570 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* ???*5*["memoizedProps"] - ⚠️ unknown object -- *5* arguments[0] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *6* ???*7*["memoizedState"] - ⚠️ unknown object -- *7* ???*8*["stateNode"] - ⚠️ unknown object -- *8* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *9* ???*10*["memoizedState"] +- *3* ???*4*["stateNode"] ⚠️ unknown object +- *4* c + ⚠️ circular variable reference + +0 -> 5571 conditional = (false | ???*0* | ???*1* | ???*2* | true) +- *0* Yj + ⚠️ circular variable reference +- *1* unsupported expression ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] +- *2* ???*3*["next"] ⚠️ unknown object +- *3* e + ⚠️ circular variable reference + +5571 -> 5574 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *11* unsupported expression + +5574 -> 5577 member call = ???*0*["removeChild"]((???*1* | ???*2*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *12* ???*13*["style"] +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* ???*3*["stateNode"] ⚠️ unknown object +- *3* c + ⚠️ circular variable reference + +5574 -> 5579 member call = ???*0*["removeChild"]((???*1* | ???*2*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *13* ???*14*["stateNode"] +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* ???*3*["stateNode"] ⚠️ unknown object +- *3* c + ⚠️ circular variable reference + +5571 -> 5582 member call = ???*0*["removeChild"](???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *14* unsupported expression +- *1* ???*2*["stateNode"] + ⚠️ unknown object +- *2* arguments[2] + ⚠️ function calls are not analysed yet + +0 -> 5583 conditional = (false | ???*0* | ???*1* | ???*2* | true) +- *0* Yj + ⚠️ circular variable reference +- *1* unsupported expression ⚠️ This value might have side effects +- *2* ???*3*["next"] + ⚠️ unknown object +- *3* e + ⚠️ circular variable reference -4932 -> 4956 conditional = ???*0* +5583 -> 5586 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -4956 -> 4958 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), !(???*4*), ???*12*, false) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] +5586 -> 5588 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*1* | ???*2*)) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* arguments[2] ⚠️ function calls are not analysed yet - *2* ???*3*["stateNode"] ⚠️ unknown object +- *3* c + ⚠️ circular variable reference + +5586 -> 5590 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*1* | ???*2*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* !((???*5* | ???*8*)) - ⚠️ nested operation -- *5* ???*6*["multiple"] - ⚠️ unknown object -- *6* ???*7*["memoizedProps"] - ⚠️ unknown object -- *7* arguments[0] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *8* ???*9*["multiple"] +- *2* ???*3*["stateNode"] ⚠️ unknown object +- *3* c + ⚠️ circular variable reference + +5583 -> 5591 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *9* ???*10*["style"] - ⚠️ unknown object + +5583 -> 5593 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] +- *1* ???*2*["stateNode"] ⚠️ unknown object +- *2* arguments[2] + ⚠️ function calls are not analysed yet + +0 -> 5596 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *11* unsupported expression +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] + ⚠️ unknown object +- *4* c + ⚠️ circular variable reference + +0 -> 5599 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *12* max number of linking steps reached + +5599 -> 5603 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -4956 -> 4961 conditional = (null != (???*0* | ???*3*)) -- *0* ???*1*["defaultValue"] - ⚠️ unknown object -- *1* ???*2*["memoizedProps"] - ⚠️ unknown object -- *2* arguments[0] +5603 -> 5604 call = (...) => undefined( + (???*0* | ???*1*), + ???*3*, + (false["destroy"] | ???*4* | true["destroy"] | ???*6*) +) +- *0* arguments[2] ⚠️ function calls are not analysed yet -- *3* ???*4*["defaultValue"] +- *1* ???*2*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *4* ???*5*["style"] +- *2* c + ⚠️ circular variable reference +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* ???*5*["destroy"] ⚠️ unknown object - ⚠️ This value might have side effects -- *5* ???*6*["stateNode"] +- *5* e + ⚠️ circular variable reference +- *6* ???*7*["destroy"] ⚠️ unknown object ⚠️ This value might have side effects -- *6* unsupported expression +- *7* unsupported expression ⚠️ This value might have side effects -4961 -> 4964 call = (...) => (undefined | FreeVar(undefined))( - (???*0* | ???*2*), - !(???*4*), - (???*12* | (null !== (???*15* | ???*18*))["defaultValue"] | ???*21*), - true +5603 -> 5605 call = (...) => undefined( + (???*0* | ???*1*), + ???*3*, + (false["destroy"] | ???*4* | true["destroy"] | ???*6*) ) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] +- *0* arguments[2] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* !((???*5* | ???*8*)) - ⚠️ nested operation -- *5* ???*6*["multiple"] - ⚠️ unknown object -- *6* ???*7*["memoizedProps"] +- *1* ???*2*["stateNode"] ⚠️ unknown object -- *7* arguments[0] +- *2* c + ⚠️ circular variable reference +- *3* arguments[1] ⚠️ function calls are not analysed yet -- *8* ???*9*["multiple"] +- *4* ???*5*["destroy"] ⚠️ unknown object - ⚠️ This value might have side effects -- *9* ???*10*["style"] +- *5* e + ⚠️ circular variable reference +- *6* ???*7*["destroy"] ⚠️ unknown object ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] - ⚠️ unknown object +- *7* unsupported expression ⚠️ This value might have side effects -- *11* unsupported expression + +0 -> 5607 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *12* ???*13*["defaultValue"] - ⚠️ unknown object -- *13* ???*14*["memoizedProps"] - ⚠️ unknown object -- *14* arguments[0] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *15* ???*16*["memoizedState"] - ⚠️ unknown object -- *16* ???*17*["stateNode"] - ⚠️ unknown object -- *17* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *18* ???*19*["memoizedState"] +- *3* ???*4*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *19* ???*20*["stateNode"] +- *4* c + ⚠️ circular variable reference + +0 -> 5608 call = (...) => undefined((???*0* | ???*1*), ???*3*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object +- *2* c + ⚠️ circular variable reference +- *3* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 5611 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *20* unsupported expression + +5611 -> 5617 member call = ???*0*["componentWillUnmount"]() +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *21* ???*22*["defaultValue"] + +5611 -> 5618 call = (...) => undefined((???*0* | ???*1*), ???*3*, ???*4*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object +- *2* c + ⚠️ circular variable reference +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* h + ⚠️ pattern without value + +0 -> 5619 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *22* ???*23*["style"] +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] ⚠️ unknown object +- *4* c + ⚠️ circular variable reference + +0 -> 5620 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *23* ???*24*["stateNode"] +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *24* unsupported expression - ⚠️ This value might have side effects +- *4* c + ⚠️ circular variable reference -4961 -> 4967 conditional = (???*0* | (null !== (???*3* | ???*6*))["multiple"] | ???*9*) -- *0* ???*1*["multiple"] - ⚠️ unknown object -- *1* ???*2*["memoizedProps"] - ⚠️ unknown object -- *2* arguments[0] +0 -> 5623 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *3* ???*4*["memoizedState"] - ⚠️ unknown object -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *6* ???*7*["memoizedState"] +- *3* ???*4*["stateNode"] ⚠️ unknown object +- *4* c + ⚠️ circular variable reference + +0 -> 5624 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *7* ???*8*["stateNode"] +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] ⚠️ unknown object +- *4* c + ⚠️ circular variable reference + +0 -> 5625 call = (...) => undefined(???*0*, ???*1*, (???*2* | ???*3*)) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *8* unsupported expression - ⚠️ This value might have side effects -- *9* ???*10*["multiple"] +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *10* ???*11*["style"] +- *4* c + ⚠️ circular variable reference + +0 -> 5627 conditional = (null !== ???*0*) +- *0* ???*1*["updateQueue"] ⚠️ unknown object - ⚠️ This value might have side effects -- *11* ???*12*["stateNode"] +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +5627 -> 5632 member call = ???*0*["forEach"]((...) => undefined) +- *0* ???*1*["updateQueue"] ⚠️ unknown object - ⚠️ This value might have side effects -- *12* unsupported expression - ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +5632 -> 5634 member call = (...) => undefined["bind"](null, ???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[0] + ⚠️ function calls are not analysed yet -4961 -> 4968 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), !(???*4*), ((???*12* | ???*15*) ? [] : ""), false) +5632 -> 5636 member call = (???*0* | ???*2*)["has"](???*3*) - *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unsupported expression +- *2* unsupported expression ⚠️ This value might have side effects -- *4* !((???*5* | ???*8*)) - ⚠️ nested operation -- *5* ???*6*["multiple"] - ⚠️ unknown object -- *6* ???*7*["memoizedProps"] - ⚠️ unknown object -- *7* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *8* ???*9*["multiple"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *9* ???*10*["style"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *10* ???*11*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *11* unsupported expression - ⚠️ This value might have side effects -- *12* ???*13*["multiple"] - ⚠️ unknown object -- *13* ???*14*["memoizedProps"] + +5632 -> 5638 member call = (???*0* | ???*2*)["add"](???*3*) +- *0* ???*1*["stateNode"] ⚠️ unknown object -- *14* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *15* ???*16*["multiple"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *16* ???*17*["style"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *17* ???*18*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *18* unsupported expression +- *2* unsupported expression ⚠️ This value might have side effects +- *3* arguments[0] + ⚠️ function calls are not analysed yet -4932 -> 4971 call = (...) => undefined(???*0*, ???*1*, ???*3*) +5632 -> 5640 member call = ???*0*["then"]((...) => undefined["bind"](null, ???*1*, ???*2*), (...) => undefined["bind"](null, ???*3*, ???*4*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] - ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet - *2* arguments[0] ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value - -0 -> 4972 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 4973 call = (...) => undefined(???*0*) -- *0* arguments[0] +- *4* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4975 conditional = (null === ???*0*) -- *0* ???*1*["stateNode"] +0 -> 5642 conditional = (null !== ???*0*) +- *0* ???*1*["deletions"] ⚠️ unknown object -- *1* arguments[0] +- *1* arguments[1] ⚠️ function calls are not analysed yet -4975 -> 4976 free var = FreeVar(Error) +5642 -> 5652 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +5652 -> 5653 free var = FreeVar(Error) -4975 -> 4977 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(162) +5652 -> 5654 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(160) -4975 -> 4978 call = ???*0*( - `Minified React error #${162}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +5652 -> 5655 call = ???*0*( + `Minified React error #${160}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${162}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${160}` ⚠️ nested operation -0 -> 4983 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] +5642 -> 5656 call = (...) => undefined(???*0*, (???*1* | ???*2*), ???*4*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* ???*3*["child"] + ⚠️ unknown object +- *3* b + ⚠️ circular variable reference +- *4* ???*5*[d] + ⚠️ unknown object +- *5* ???*6*["deletions"] + ⚠️ unknown object +- *6* arguments[1] + ⚠️ function calls are not analysed yet + +5642 -> 5660 call = (...) => undefined(???*0*, (???*3* | ???*4*), ???*6*) +- *0* ???*1*[d] + ⚠️ unknown object +- *1* ???*2*["deletions"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* ???*5*["child"] + ⚠️ unknown object +- *5* b + ⚠️ circular variable reference +- *6* l + ⚠️ pattern without value + +0 -> 5663 call = (...) => undefined((???*0* | ???*1*), ???*3*) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +- *1* ???*2*["child"] ⚠️ unknown object -- *2* arguments[0] +- *2* b + ⚠️ circular variable reference +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value -0 -> 4984 call = (...) => undefined(???*0*, ???*1*) +0 -> 5668 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4985 call = (...) => undefined(???*0*) +0 -> 5669 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4988 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4988 -> 4990 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -4988 -> 4992 call = (...) => undefined(???*0*, ???*1*, ???*3*) +0 -> 5671 call = (...) => undefined(3, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet - *1* ???*2*["return"] ⚠️ unknown object - *2* arguments[0] ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value -0 -> 4993 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* arguments[0] +0 -> 5672 call = (...) => undefined(3, ???*0*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4994 call = (...) => undefined(???*0*) +0 -> 5674 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 4995 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* arguments[0] +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value -0 -> 4996 call = (...) => undefined(???*0*) +0 -> 5676 call = (...) => undefined(5, ???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5005 call = module["unstable_now"]() - -0 -> 5006 call = (...) => undefined(???*0*) +0 -> 5678 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 5009 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* arguments[0] +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value -0 -> 5010 call = (...) => undefined(???*0*, ???*1*) +0 -> 5679 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -0 -> 5011 call = (...) => undefined(???*0*) +0 -> 5680 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 5016 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5016 -> 5021 call = (...) => undefined(4, ???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -5016 -> 5023 call = (...) => undefined(???*0*, ???*1*) +0 -> 5682 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -5016 -> 5026 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5026 -> 5033 member call = ???*0*["componentWillUnmount"]() +0 -> 5683 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -5026 -> 5034 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* t - ⚠️ pattern without value +0 -> 5684 call = (...) => undefined(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5016 -> 5036 call = (...) => undefined(???*0*, ???*1*) +0 -> 5686 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -5016 -> 5038 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5038 -> 5039 call = (...) => undefined((???*0* | ???*3* | ???*4*)) -- *0* ???*1*[(g + 1)] - ⚠️ unknown object -- *1* ???*2*["updateQueue"] +0 -> 5689 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), "") +- *0* ???*1*["stateNode"] ⚠️ unknown object -- *2* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *3* unsupported expression +- *2* ???*3*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *4* arguments[0] - ⚠️ function calls are not analysed yet - -5016 -> 5040 conditional = ???*0* -- *0* max number of linking steps reached +- *3* unsupported expression ⚠️ This value might have side effects -5040 -> 5042 call = (...) => undefined((???*0* | ???*3* | ???*4*)) -- *0* ???*1*[(g + 1)] - ⚠️ unknown object -- *1* ???*2*["updateQueue"] +0 -> 5691 call = (...) => undefined(???*0*, ???*1*, ???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["return"] ⚠️ unknown object - *2* arguments[0] ⚠️ function calls are not analysed yet -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* arguments[0] - ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value -0 -> 5045 conditional = (5 === (???*0* | ???*4*)) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* ???*2*[(g + 1)] - ⚠️ unknown object -- *2* ???*3*["updateQueue"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["tag"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *5* unsupported expression +0 -> 5693 conditional = (???*0* | ???*1*) +- *0* unsupported expression ⚠️ This value might have side effects - -5045 -> 5046 conditional = ???*0* -- *0* max number of linking steps reached +- *1* (null != e) + ⚠️ sequence with side effects ⚠️ This value might have side effects -5046 -> 5048 conditional = ???*0* +5693 -> 5695 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5048 -> 5051 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | ???*4*)) - ⚠️ nested operation -- *1* ???*2*["setProperty"] - ⚠️ unknown object -- *2* ???*3*["memoizedProps"] +5693 -> 5700 conditional = (null !== (???*0* | ???*2*)) +- *0* ???*1*["updateQueue"] ⚠️ unknown object -- *3* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["setProperty"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *5* ???*6*["style"] +- *2* ???*3*["style"] ⚠️ unknown object ⚠️ This value might have side effects -- *6* ???*7*["stateNode"] +- *3* ???*4*["memoizedProps"] ⚠️ unknown object ⚠️ This value might have side effects -- *7* unsupported expression +- *4* unsupported expression ⚠️ This value might have side effects -5051 -> 5053 member call = (???*0* | (null !== (???*2* | ???*5*)) | ???*8*)["setProperty"]("display", "none", "important") -- *0* ???*1*["memoizedProps"] +5700 -> 5703 call = (...) => undefined((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) +- *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["memoizedState"] +- *2* ???*3*["stateNode"] ⚠️ unknown object -- *3* ???*4*["stateNode"] + ⚠️ This value might have side effects +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* ???*5*["memoizedProps"] ⚠️ unknown object -- *4* arguments[0] +- *5* arguments[0] ⚠️ function calls are not analysed yet -- *5* ???*6*["memoizedState"] +- *6* ???*7*["memoizedState"] + ⚠️ unknown object +- *7* ???*8*["stateNode"] + ⚠️ unknown object +- *8* arguments[0] + ⚠️ function calls are not analysed yet +- *9* ???*10*["memoizedState"] ⚠️ unknown object ⚠️ This value might have side effects -- *6* ???*7*["stateNode"] +- *10* ???*11*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *7* unsupported expression +- *11* unsupported expression ⚠️ This value might have side effects -- *8* ???*9*["style"] +- *12* ???*13*["style"] ⚠️ unknown object ⚠️ This value might have side effects -- *9* ???*10*["stateNode"] +- *13* ???*14*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *10* unsupported expression +- *14* unsupported expression ⚠️ This value might have side effects -5048 -> 5059 member call = (???*0* | ???*2*)["hasOwnProperty"]("display") -- *0* ???*1*["updateQueue"] +5700 -> 5704 call = (...) => (undefined | ("string" === typeof(b["is"])) | !(1) | !(0))((???*0* | ???*2*), ???*4*) +- *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["style"] +- *2* ???*3*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *3* ???*4*["memoizedProps"] - ⚠️ unknown object +- *3* unsupported expression ⚠️ This value might have side effects -- *4* unsupported expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -5048 -> 5060 conditional = ((???*0* !== (???*1* | ???*3*)) | (null !== (???*6* | ???*8*)) | ???*11* | ???*14*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* ???*2*["updateQueue"] +5700 -> 5705 call = (...) => (undefined | ("string" === typeof(b["is"])) | !(1) | !(0))((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) +- *0* ???*1*["type"] ⚠️ unknown object -- *2* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *3* ???*4*["style"] +- *2* ???*3*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects +- *3* unsupported expression + ⚠️ This value might have side effects - *4* ???*5*["memoizedProps"] ⚠️ unknown object - ⚠️ This value might have side effects -- *5* unsupported expression - ⚠️ This value might have side effects -- *6* ???*7*["updateQueue"] +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["memoizedState"] ⚠️ unknown object -- *7* arguments[0] +- *7* ???*8*["stateNode"] + ⚠️ unknown object +- *8* arguments[0] ⚠️ function calls are not analysed yet -- *8* ???*9*["style"] +- *9* ???*10*["memoizedState"] ⚠️ unknown object ⚠️ This value might have side effects -- *9* ???*10*["memoizedProps"] +- *10* ???*11*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *10* unsupported expression - ⚠️ This value might have side effects -- *11* ???*12*["hasOwnProperty"]("display") - ⚠️ unknown callee object -- *12* ???*13*["updateQueue"] - ⚠️ unknown object -- *13* arguments[0] - ⚠️ function calls are not analysed yet -- *14* ???*15*["hasOwnProperty"]("display") - ⚠️ unknown callee object +- *11* unsupported expression ⚠️ This value might have side effects -- *15* ???*16*["style"] +- *12* ???*13*["style"] ⚠️ unknown object ⚠️ This value might have side effects -- *16* ???*17*["memoizedProps"] +- *13* ???*14*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *17* unsupported expression +- *14* unsupported expression ⚠️ This value might have side effects -5048 -> 5064 call = (...) => (((null == b) || ("boolean" === typeof(b)) || ("" === b)) ? "" : ((c || ("number" !== typeof(b)) || (0 === b) || (pb["hasOwnProperty"](a) && pb[a])) ? `${b}`["trim"]() : `${b}px`))("display", ???*0*) +5700 -> 5709 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5046 -> 5066 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +5709 -> 5710 call = (...) => undefined((???*0* | ???*2*), (???*4* | ???*7* | ???*8*)) +- *0* ???*1*["stateNode"] ⚠️ unknown object -- *2* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value - -5045 -> 5068 conditional = (6 === (???*0* | ???*4*)) -- *0* ???*1*["tag"] +- *2* ???*3*["stateNode"] ⚠️ unknown object -- *1* ???*2*[(g + 1)] + ⚠️ This value might have side effects +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* ???*5*[(g + 1)] ⚠️ unknown object -- *2* ???*3*["updateQueue"] +- *5* ???*6*["updateQueue"] ⚠️ unknown object -- *3* arguments[0] +- *6* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["tag"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *5* unsupported expression - ⚠️ This value might have side effects - -5068 -> 5069 conditional = ???*0* -- *0* max number of linking steps reached +- *7* unsupported expression ⚠️ This value might have side effects +- *8* arguments[0] + ⚠️ function calls are not analysed yet -5069 -> 5072 conditional = ???*0* +5709 -> 5711 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5069 -> 5075 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* t - ⚠️ pattern without value - -5068 -> 5080 conditional = ( - | (22 !== (???*0* | ???*4*)) - | (23 !== (???*6* | ???*10*)) - | (null === (???*12* | ???*16*)) - | ((???*18* | ???*21* | ???*22*) === ???*23*) - | (null !== (???*24* | ???*28*)) -) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* ???*2*[(g + 1)] - ⚠️ unknown object -- *2* ???*3*["updateQueue"] +5711 -> 5712 call = ???*0*((???*2* | ???*4*), (???*6* | ???*9* | ???*10*)) +- *0* ???*1*(*anonymous function 13608*) + ⚠️ unknown callee +- *1* *anonymous function 13449* + ⚠️ no value of this variable analysed +- *2* ???*3*["stateNode"] ⚠️ unknown object - *3* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["tag"] +- *4* ???*5*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects - *5* unsupported expression ⚠️ This value might have side effects -- *6* ???*7*["tag"] - ⚠️ unknown object -- *7* ???*8*[(g + 1)] +- *6* ???*7*[(g + 1)] ⚠️ unknown object -- *8* ???*9*["updateQueue"] +- *7* ???*8*["updateQueue"] ⚠️ unknown object -- *9* arguments[0] +- *8* arguments[0] ⚠️ function calls are not analysed yet -- *10* ???*11*["tag"] - ⚠️ unknown object +- *9* unsupported expression ⚠️ This value might have side effects -- *11* unsupported expression +- *10* arguments[0] + ⚠️ function calls are not analysed yet + +5711 -> 5713 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *12* ???*13*["memoizedState"] - ⚠️ unknown object -- *13* ???*14*[(g + 1)] - ⚠️ unknown object -- *14* ???*15*["updateQueue"] + +5713 -> 5714 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), (???*4* | ???*7* | ???*8*)) +- *0* ???*1*["stateNode"] ⚠️ unknown object -- *15* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *16* ???*17*["memoizedState"] +- *2* ???*3*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *17* unsupported expression +- *3* unsupported expression ⚠️ This value might have side effects -- *18* ???*19*[(g + 1)] +- *4* ???*5*[(g + 1)] ⚠️ unknown object -- *19* ???*20*["updateQueue"] +- *5* ???*6*["updateQueue"] ⚠️ unknown object -- *20* arguments[0] +- *6* arguments[0] ⚠️ function calls are not analysed yet -- *21* unsupported expression +- *7* unsupported expression ⚠️ This value might have side effects -- *22* arguments[0] - ⚠️ function calls are not analysed yet -- *23* arguments[0] +- *8* arguments[0] ⚠️ function calls are not analysed yet -- *24* ???*25*["child"] - ⚠️ unknown object -- *25* ???*26*[(g + 1)] - ⚠️ unknown object -- *26* ???*27*["updateQueue"] + +5713 -> 5715 call = (...) => undefined((???*0* | ???*2*), ???*4*, (???*5* | ???*8* | ???*9*), ???*10*) +- *0* ???*1*["stateNode"] ⚠️ unknown object -- *27* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *28* ???*29*["child"] +- *2* ???*3*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *29* unsupported expression +- *3* unsupported expression ⚠️ This value might have side effects - -0 -> 5092 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5093 call = (...) => undefined(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5094 call = (...) => undefined(???*0*) -- *0* arguments[0] +- *5* ???*6*[(g + 1)] + ⚠️ unknown object +- *6* ???*7*["updateQueue"] + ⚠️ unknown object +- *7* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 5095 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +- *8* unsupported expression ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5096 call = (...) => undefined(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5099 call = (...) => ((5 === a["tag"]) || (3 === a["tag"]) || (4 === a["tag"]))(???*0*) -- *0* ???*1*["return"] - ⚠️ unknown object -- *1* arguments[0] +- *9* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 5101 free var = FreeVar(Error) - -0 -> 5102 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(160) - -0 -> 5103 call = ???*0*( - `Minified React error #${160}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *10* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${160}` - ⚠️ nested operation -0 -> 5107 call = (...) => (undefined | FreeVar(undefined))(???*0*, "") +5700 -> 5716 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) - *0* ???*1*["stateNode"] ⚠️ unknown object -- *1* ???*2*["return"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5109 call = (...) => (undefined | null | a["stateNode"])(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5110 call = (...) => undefined(???*0*, (undefined | null | ???*1*), ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *3* ???*4*["stateNode"] +- *2* ???*3*["stateNode"] ⚠️ unknown object -- *4* ???*5*["return"] + ⚠️ This value might have side effects +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* ???*5*["memoizedProps"] ⚠️ unknown object - *5* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 5113 call = (...) => (undefined | null | a["stateNode"])(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5114 call = (...) => undefined(???*0*, (undefined | null | ???*1*), ???*3*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["containerInfo"] - ⚠️ unknown object -- *4* ???*5*["stateNode"] +- *6* ???*7*["memoizedState"] ⚠️ unknown object -- *5* ???*6*["return"] +- *7* ???*8*["stateNode"] ⚠️ unknown object -- *6* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5115 free var = FreeVar(Error) - -0 -> 5116 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(161) - -0 -> 5117 call = ???*0*( - `Minified React error #${161}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${161}` - ⚠️ nested operation - -0 -> 5119 call = (...) => undefined(???*0*, ???*1*, ???*3*) -- *0* arguments[0] +- *8* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] +- *9* ???*10*["memoizedState"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* k - ⚠️ pattern without value - -0 -> 5122 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet - -0 -> 5126 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5126 -> 5128 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5128 -> 5131 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5131 -> 5135 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5135 -> 5136 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5135 -> 5137 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5137 -> 5139 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5128 -> 5140 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet - -5126 -> 5142 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet - -5126 -> 5144 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5144 -> 5146 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet - -0 -> 5148 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -5148 -> 5151 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -5151 -> 5153 call = (...) => undefined(5, ???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5151 -> 5156 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5156 -> 5157 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5157 -> 5159 member call = ???*0*["componentDidMount"]() -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5157 -> 5162 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5162 -> 5166 call = (...) => b(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached ⚠️ This value might have side effects - -5157 -> 5170 member call = ???*0*["componentDidUpdate"](???*1*, ???*2*, ???*3*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *10* ???*11*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5151 -> 5172 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *11* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *12* ???*13*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *13* ???*14*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5151 -> 5174 conditional = ???*0* -- *0* max number of linking steps reached +- *14* unsupported expression ⚠️ This value might have side effects -5174 -> 5176 conditional = ???*0* -- *0* max number of linking steps reached +5700 -> 5717 call = (...) => undefined((???*0* | ???*2*), (???*4* | (null !== (???*6* | ???*9*)) | ???*12*)) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5174 -> 5183 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *3* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *4* ???*5*["memoizedProps"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["memoizedState"] + ⚠️ unknown object +- *7* ???*8*["stateNode"] + ⚠️ unknown object +- *8* arguments[0] + ⚠️ function calls are not analysed yet +- *9* ???*10*["memoizedState"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *10* ???*11*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5151 -> 5186 conditional = ???*0* -- *0* max number of linking steps reached +- *11* unsupported expression ⚠️ This value might have side effects - -5186 -> 5191 member call = ???*0*["focus"]() -- *0* max number of linking steps reached +- *12* ???*13*["style"] + ⚠️ unknown object ⚠️ This value might have side effects - -5151 -> 5196 conditional = ???*0* -- *0* max number of linking steps reached +- *13* ???*14*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5196 -> 5198 conditional = ???*0* -- *0* max number of linking steps reached +- *14* unsupported expression ⚠️ This value might have side effects -5198 -> 5200 conditional = ???*0* +5700 -> 5724 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5200 -> 5202 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +5724 -> 5726 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), !(???*4*), ???*12*, false) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5151 -> 5203 free var = FreeVar(Error) - -5151 -> 5204 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(163) - -5151 -> 5205 call = ???*0*( - `Minified React error #${163}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *3* unsupported expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${163}` +- *4* !((???*5* | ???*8*)) ⚠️ nested operation - -5148 -> 5207 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +- *5* ???*6*["multiple"] + ⚠️ unknown object +- *6* ???*7*["memoizedProps"] + ⚠️ unknown object +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* ???*9*["multiple"] + ⚠️ unknown object ⚠️ This value might have side effects - -5148 -> 5209 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *9* ???*10*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *10* ???*11*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* r - ⚠️ pattern without value - -0 -> 5211 conditional = ???*0* -- *0* max number of linking steps reached +- *11* unsupported expression ⚠️ This value might have side effects - -0 -> 5216 conditional = ???*0* -- *0* max number of linking steps reached +- *12* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5222 call = (...) => undefined(4, ???*0*) -- *0* max number of linking steps reached +5724 -> 5729 conditional = (null != (???*0* | ???*3*)) +- *0* ???*1*["defaultValue"] + ⚠️ unknown object +- *1* ???*2*["memoizedProps"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["defaultValue"] + ⚠️ unknown object ⚠️ This value might have side effects - -0 -> 5223 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *4* ???*5*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *5* ???*6*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* k - ⚠️ pattern without value - -0 -> 5226 conditional = ???*0* -- *0* max number of linking steps reached +- *6* unsupported expression ⚠️ This value might have side effects -5226 -> 5229 member call = ???*0*["componentDidMount"]() -- *0* max number of linking steps reached +5729 -> 5732 call = (...) => (undefined | FreeVar(undefined))( + (???*0* | ???*2*), + !(???*4*), + (???*12* | (null !== (???*15* | ???*18*))["defaultValue"] | ???*21*), + true +) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -5226 -> 5230 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *3* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *4* !((???*5* | ???*8*)) + ⚠️ nested operation +- *5* ???*6*["multiple"] + ⚠️ unknown object +- *6* ???*7*["memoizedProps"] + ⚠️ unknown object +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* ???*9*["multiple"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* k - ⚠️ pattern without value - -0 -> 5232 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +- *9* ???*10*["style"] + ⚠️ unknown object ⚠️ This value might have side effects - -0 -> 5233 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *10* ???*11*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *11* unsupported expression ⚠️ This value might have side effects -- *2* k - ⚠️ pattern without value - -0 -> 5235 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +- *12* ???*13*["defaultValue"] + ⚠️ unknown object +- *13* ???*14*["memoizedProps"] + ⚠️ unknown object +- *14* arguments[0] + ⚠️ function calls are not analysed yet +- *15* ???*16*["memoizedState"] + ⚠️ unknown object +- *16* ???*17*["stateNode"] + ⚠️ unknown object +- *17* arguments[0] + ⚠️ function calls are not analysed yet +- *18* ???*19*["memoizedState"] + ⚠️ unknown object ⚠️ This value might have side effects - -0 -> 5236 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *19* ???*20*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *20* unsupported expression ⚠️ This value might have side effects -- *2* k - ⚠️ pattern without value - -0 -> 5238 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *21* ???*22*["defaultValue"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *22* ???*23*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* k - ⚠️ pattern without value - -0 -> 5240 conditional = ???*0* -- *0* max number of linking steps reached +- *23* ???*24*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - -0 -> 5245 free var = FreeVar(Math) - -0 -> 5249 call = (...) => {"current": a}(0) - -0 -> 5250 free var = FreeVar(Infinity) - -0 -> 5251 conditional = (0 !== ???*0*) -- *0* unsupported expression +- *24* unsupported expression ⚠️ This value might have side effects -5251 -> 5252 call = module["unstable_now"]() - -5251 -> 5253 conditional = (???*0* !== (???*1* | ???*2*)) -- *0* unsupported expression +5729 -> 5735 conditional = (???*0* | (null !== (???*3* | ???*6*))["multiple"] | ???*9*) +- *0* ???*1*["multiple"] + ⚠️ unknown object +- *1* ???*2*["memoizedProps"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["memoizedState"] + ⚠️ unknown object +- *4* ???*5*["stateNode"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["memoizedState"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* unsupported expression +- *7* ???*8*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* module["unstable_now"]() - ⚠️ nested operation - -5253 -> 5254 call = module["unstable_now"]() - -0 -> 5257 conditional = (null !== module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentBatchConfig"]["transition"]) - -5257 -> 5258 call = (...) => a() - -0 -> 5260 free var = FreeVar(window) - -0 -> 5261 conditional = (???*0* === (???*1* | 0 | 1 | ???*2* | 4 | ???*3* | ???*8*)) -- *0* unsupported expression +- *8* unsupported expression ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* C - ⚠️ circular variable reference -- *3* ((???*4* | ???*6*) ? ???*7* : 4) - ⚠️ nested operation -- *4* (0 !== ???*5*) - ⚠️ nested operation -- *5* C - ⚠️ circular variable reference -- *6* unsupported expression +- *9* ???*10*["multiple"] + ⚠️ unknown object ⚠️ This value might have side effects -- *7* C - ⚠️ circular variable reference -- *8* ???*9*["event"] +- *10* ???*11*["style"] ⚠️ unknown object ⚠️ This value might have side effects -- *9* FreeVar(window) - ⚠️ unknown global +- *11* ???*12*["stateNode"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *12* unsupported expression ⚠️ This value might have side effects -5261 -> 5263 call = (...) => (undefined | 1 | 4 | 16 | 536870912)( - ( - | ???*0* - | 0["type"] - | 1["type"] - | 4["type"] - | ((???*2* | ???*4*) ? ???*5* : 4)["type"] - | (???*6* ? 16 : (???*7* | null | ???*14* | ???*15*))["type"] - | ???*17* - | (???*20* ? 16 : (undefined | 1 | 4 | 16 | 536870912))["type"] - ) -) -- *0* ???*1*["type"] +5729 -> 5736 call = (...) => (undefined | FreeVar(undefined))((???*0* | ???*2*), !(???*4*), ((???*12* | ???*15*) ? [] : ""), false) +- *0* ???*1*["stateNode"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* (0 !== ???*3*) - ⚠️ nested operation -- *3* C - ⚠️ circular variable reference -- *4* unsupported expression +- *2* ???*3*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *5* C - ⚠️ circular variable reference -- *6* unsupported expression +- *3* unsupported expression ⚠️ This value might have side effects -- *7* (???*8* ? ???*9* : 1) +- *4* !((???*5* | ???*8*)) ⚠️ nested operation -- *8* unsupported expression +- *5* ???*6*["multiple"] + ⚠️ unknown object +- *6* ???*7*["memoizedProps"] + ⚠️ unknown object +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* ???*9*["multiple"] + ⚠️ unknown object ⚠️ This value might have side effects -- *9* (???*10* ? ???*11* : 4) - ⚠️ nested operation -- *10* unsupported expression +- *9* ???*10*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *11* (???*12* ? 16 : 536870912) - ⚠️ nested operation -- *12* (0 !== ???*13*) - ⚠️ nested operation -- *13* unsupported expression +- *10* ???*11*["stateNode"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *11* unsupported expression ⚠️ This value might have side effects +- *12* ???*13*["multiple"] + ⚠️ unknown object +- *13* ???*14*["memoizedProps"] + ⚠️ unknown object - *14* arguments[0] ⚠️ function calls are not analysed yet -- *15* ???*16*["value"] +- *15* ???*16*["multiple"] ⚠️ unknown object -- *16* arguments[1] - ⚠️ function calls are not analysed yet -- *17* ???*18*["type"] + ⚠️ This value might have side effects +- *16* ???*17*["style"] ⚠️ unknown object ⚠️ This value might have side effects -- *18* ???*19*["event"] +- *17* ???*18*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *19* FreeVar(window) - ⚠️ unknown global +- *18* unsupported expression ⚠️ This value might have side effects -- *20* (???*21* === ???*22*) - ⚠️ nested operation -- *21* unsupported expression + +5700 -> 5739 call = (...) => undefined(???*0*, ???*1*, ???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value + +0 -> 5740 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *22* a - ⚠️ circular variable reference +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 5741 call = (...) => undefined(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 5743 conditional = (null === ???*0*) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5264 free var = FreeVar(Error) +5743 -> 5744 free var = FreeVar(Error) -0 -> 5265 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(185) +5743 -> 5745 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(162) -0 -> 5266 call = ???*0*( - `Minified React error #${185}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +5743 -> 5746 call = ???*0*( + `Minified React error #${162}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${185}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${162}` ⚠️ nested operation -0 -> 5267 call = (...) => undefined(???*0*, ???*1*, ???*2*) +0 -> 5751 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[3] +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value -0 -> 5268 conditional = ((0 === ???*0*) | (???*1* !== (null | ???*2* | ???*3* | ???*6*))) -- *0* unsupported expression +0 -> 5752 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["alternate"] - ⚠️ unknown object -- *4* ???*5*["current"] - ⚠️ unknown object -- *5* a - ⚠️ circular variable reference -- *6* unknown new expression - ⚠️ This value might have side effects -5268 -> 5269 call = (...) => undefined(???*0*, (0 | ???*1*)) +0 -> 5753 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* unsupported expression + +0 -> 5756 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +5756 -> 5758 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -5268 -> 5270 call = (...) => undefined(???*0*, ???*1*) +5756 -> 5760 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[3] +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value -5268 -> 5272 call = module["unstable_now"]() - -5268 -> 5273 call = (...) => null() +0 -> 5761 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5275 call = (...) => undefined(???*0*, (???*1* | ???*2*)) +0 -> 5762 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* unsupported expression + +0 -> 5763 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 5764 call = (...) => undefined(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5276 conditional = (???*0* === (null | ???*1* | ???*2* | ???*5*)) +0 -> 5773 call = module["unstable_now"]() + +0 -> 5774 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet + +0 -> 5777 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["alternate"] - ⚠️ unknown object -- *3* ???*4*["current"] - ⚠️ unknown object -- *4* a - ⚠️ circular variable reference -- *5* unknown new expression + +0 -> 5778 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5277 call = (...) => (0 | b | d)(???*0*, (???*1* ? (0 | ???*8*) : 0)) +0 -> 5779 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* (???*2* === (null | ???*3* | ???*4* | ???*7*)) - ⚠️ nested operation -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["alternate"] - ⚠️ unknown object -- *5* ???*6*["current"] - ⚠️ unknown object -- *6* a - ⚠️ circular variable reference -- *7* unknown new expression + +0 -> 5784 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *8* unsupported expression + +5784 -> 5789 call = (...) => undefined(4, ???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5278 conditional = (0 === ( - | 0 - | ???*0* - | ???*9* - | ???*11* - | undefined - | 1 - | 2 - | 4 - | 8 - | 16 - | 32 - | ???*12* - | 134217728 - | 268435456 - | 536870912 - | 1073741824 -)) -- *0* (???*1* ? (0 | ???*8*) : 0) - ⚠️ nested operation -- *1* (???*2* === (null | ???*3* | ???*4* | ???*7*)) - ⚠️ nested operation -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["alternate"] - ⚠️ unknown object -- *5* ???*6*["current"] - ⚠️ unknown object -- *6* a - ⚠️ circular variable reference -- *7* unknown new expression +5784 -> 5791 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *8* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *9* ???*10*["entangledLanes"] - ⚠️ unknown object -- *10* arguments[0] - ⚠️ function calls are not analysed yet -- *11* unsupported assign operation + +5784 -> 5794 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *12* unsupported expression + +5794 -> 5801 member call = ???*0*["componentWillUnmount"]() +- *0* max number of linking steps reached ⚠️ This value might have side effects -5278 -> 5279 call = module["unstable_cancelCallback"]( - ( - | ???*0* - | null - | module["unstable_ImmediatePriority"] - | module["unstable_UserBlockingPriority"] - | module["unstable_NormalPriority"] - | module["unstable_IdlePriority"] - | module["unstable_scheduleCallback"](???*2*, ???*3*) - ) -) -- *0* ???*1*["callbackNode"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* c - ⚠️ circular variable reference -- *3* (...) => (null | ???*4*)["bind"](null, ???*5*) - ⚠️ nested operation -- *4* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) - ⚠️ nested operation -- *5* arguments[0] - ⚠️ function calls are not analysed yet +5794 -> 5802 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* t + ⚠️ pattern without value -5278 -> 5283 call = module["unstable_cancelCallback"]( - ( - | ???*0* - | null - | module["unstable_ImmediatePriority"] - | module["unstable_UserBlockingPriority"] - | module["unstable_NormalPriority"] - | module["unstable_IdlePriority"] - | module["unstable_scheduleCallback"](???*2*, ???*3*) - ) -) -- *0* ???*1*["callbackNode"] +5784 -> 5804 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +5784 -> 5806 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +5806 -> 5807 call = (...) => undefined((???*0* | ???*3* | ???*4*)) +- *0* ???*1*[(g + 1)] ⚠️ unknown object -- *1* arguments[0] +- *1* ???*2*["updateQueue"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *2* c - ⚠️ circular variable reference -- *3* (...) => (null | ???*4*)["bind"](null, ???*5*) - ⚠️ nested operation -- *4* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) - ⚠️ nested operation -- *5* arguments[0] +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* arguments[0] ⚠️ function calls are not analysed yet -5278 -> 5284 conditional = (1 === (???*0* | ???*1*)) -- *0* arguments[1] +5784 -> 5808 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +5808 -> 5810 call = (...) => undefined((???*0* | ???*3* | ???*4*)) +- *0* ???*1*[(g + 1)] + ⚠️ unknown object +- *1* ???*2*["updateQueue"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *1* unsupported expression +- *3* unsupported expression ⚠️ This value might have side effects +- *4* arguments[0] + ⚠️ function calls are not analysed yet -5284 -> 5286 conditional = (0 === ???*0*) +0 -> 5813 conditional = (5 === (???*0* | ???*4*)) - *0* ???*1*["tag"] ⚠️ unknown object -- *1* arguments[0] +- *1* ???*2*[(g + 1)] + ⚠️ unknown object +- *2* ???*3*["updateQueue"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet +- *4* ???*5*["tag"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *5* unsupported expression + ⚠️ This value might have side effects -5286 -> 5288 member call = (...) => null["bind"](null, ???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +5813 -> 5814 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5286 -> 5289 call = (...) => undefined((...) => null["bind"](null, ???*0*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +5814 -> 5816 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5286 -> 5291 member call = (...) => null["bind"](null, ???*0*) -- *0* arguments[0] +5816 -> 5819 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | ???*4*)) + ⚠️ nested operation +- *1* ???*2*["setProperty"] + ⚠️ unknown object +- *2* ???*3*["memoizedProps"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet +- *4* ???*5*["setProperty"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *5* ???*6*["style"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* ???*7*["stateNode"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *7* unsupported expression + ⚠️ This value might have side effects -5286 -> 5292 call = (...) => undefined((...) => null["bind"](null, ???*0*)) -- *0* arguments[0] +5819 -> 5821 member call = (???*0* | (null !== (???*2* | ???*5*)) | ???*8*)["setProperty"]("display", "none", "important") +- *0* ???*1*["memoizedProps"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet - -5284 -> 5293 call = (???*0* ? ???*3* : ???*4*)((...) => undefined) -- *0* ("function" === ???*1*) - ⚠️ nested operation -- *1* typeof(???*2*) - ⚠️ nested operation -- *2* FreeVar(queueMicrotask) - ⚠️ unknown global +- *2* ???*3*["memoizedState"] + ⚠️ unknown object +- *3* ???*4*["stateNode"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* ???*6*["memoizedState"] + ⚠️ unknown object ⚠️ This value might have side effects -- *3* FreeVar(queueMicrotask) - ⚠️ unknown global +- *6* ???*7*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *4* (???*5* ? (...) => ???*11* : ???*12*) - ⚠️ nested operation -- *5* ("undefined" !== ???*6*) - ⚠️ nested operation -- *6* typeof(???*7*) - ⚠️ nested operation -- *7* (???*8* ? ???*9* : ???*10*) - ⚠️ nested operation -- *8* ("function" === ???) - ⚠️ nested operation -- *9* FreeVar(Promise) - ⚠️ unknown global +- *7* unsupported expression + ⚠️ This value might have side effects +- *8* ???*9*["style"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *9* ???*10*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects - *10* unsupported expression ⚠️ This value might have side effects -- *11* Hf["resolve"](null)["then"](a)["catch"](If) - ⚠️ nested operation -- *12* (???*13* ? ???*16* : ???*17*) - ⚠️ nested operation -- *13* ("function" === ???*14*) - ⚠️ nested operation -- *14* typeof(???*15*) - ⚠️ nested operation -- *15* FreeVar(setTimeout) - ⚠️ unknown global + +5816 -> 5827 member call = (???*0* | ???*2*)["hasOwnProperty"]("display") +- *0* ???*1*["updateQueue"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *16* FreeVar(setTimeout) - ⚠️ unknown global +- *3* ???*4*["memoizedProps"] + ⚠️ unknown object ⚠️ This value might have side effects -- *17* unsupported expression +- *4* unsupported expression ⚠️ This value might have side effects -5293 -> 5294 call = (...) => null() - -5284 -> 5295 call = (...) => (???*0* ? (???*1* ? ((0 !== ???*2*) ? 16 : 536870912) : 4) : 1)( - ( - | 0 - | (???*3* ? (0 | ???*10*) : 0) - | ???*11* - | ???*13* - | undefined - | 1 - | 2 - | 4 - | 8 - | 16 - | 32 - | ???*14* - | 134217728 - | 268435456 - | 536870912 - | 1073741824 - ) -) +5816 -> 5828 conditional = ((???*0* !== (???*1* | ???*3*)) | (null !== (???*6* | ???*8*)) | ???*11* | ???*14*) - *0* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression +- *1* ???*2*["updateQueue"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["style"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* unsupported expression +- *4* ???*5*["memoizedProps"] + ⚠️ unknown object ⚠️ This value might have side effects -- *3* (???*4* === (null | ???*5* | ???*6* | ???*9*)) - ⚠️ nested operation -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* arguments[0] +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* ???*7*["updateQueue"] + ⚠️ unknown object +- *7* arguments[0] ⚠️ function calls are not analysed yet -- *6* ???*7*["alternate"] +- *8* ???*9*["style"] ⚠️ unknown object -- *7* ???*8*["current"] + ⚠️ This value might have side effects +- *9* ???*10*["memoizedProps"] ⚠️ unknown object -- *8* a - ⚠️ circular variable reference -- *9* unknown new expression ⚠️ This value might have side effects - *10* unsupported expression ⚠️ This value might have side effects -- *11* ???*12*["entangledLanes"] +- *11* ???*12*["hasOwnProperty"]("display") + ⚠️ unknown callee object +- *12* ???*13*["updateQueue"] ⚠️ unknown object -- *12* arguments[0] +- *13* arguments[0] ⚠️ function calls are not analysed yet -- *13* unsupported assign operation +- *14* ???*15*["hasOwnProperty"]("display") + ⚠️ unknown callee object ⚠️ This value might have side effects -- *14* unsupported expression +- *15* ???*16*["style"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *16* ???*17*["memoizedProps"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *17* unsupported expression ⚠️ This value might have side effects -5284 -> 5297 member call = (...) => ( - | null - | ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) -)["bind"](null, ???*0*) +5816 -> 5832 call = (...) => (((null == b) || ("boolean" === typeof(b)) || ("" === b)) ? "" : ((c || ("number" !== typeof(b)) || (0 === b) || (pb["hasOwnProperty"](a) && pb[a])) ? `${b}`["trim"]() : `${b}px`))("display", ???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +5814 -> 5834 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet - -5284 -> 5298 call = (...) => ac(a, b)( - ( - | ???*0* - | null - | module["unstable_ImmediatePriority"] - | module["unstable_UserBlockingPriority"] - | module["unstable_NormalPriority"] - | module["unstable_IdlePriority"] - | module["unstable_scheduleCallback"](???*2*, ???*3*) - ), - (...) => (null | ???*6*)["bind"](null, ???*7*) -) -- *0* ???*1*["callbackNode"] +- *1* ???*2*["return"] ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* c - ⚠️ circular variable reference -- *3* (...) => (null | ???*4*)["bind"](null, ???*5*) - ⚠️ nested operation -- *4* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) - ⚠️ nested operation -- *5* arguments[0] - ⚠️ function calls are not analysed yet -- *6* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) - ⚠️ nested operation -- *7* arguments[0] +- *2* arguments[0] ⚠️ function calls are not analysed yet +- *3* t + ⚠️ pattern without value -0 -> 5301 conditional = (0 !== ???*0*) -- *0* unsupported expression +5813 -> 5836 conditional = (6 === (???*0* | ???*4*)) +- *0* ???*1*["tag"] + ⚠️ unknown object +- *1* ???*2*[(g + 1)] + ⚠️ unknown object +- *2* ???*3*["updateQueue"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["tag"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *5* unsupported expression ⚠️ This value might have side effects -5301 -> 5302 free var = FreeVar(Error) - -5301 -> 5303 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(327) - -5301 -> 5304 call = ???*0*( - `Minified React error #${327}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +5836 -> 5837 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${327}` - ⚠️ nested operation -0 -> 5306 call = (...) => (d | !(1))() +5837 -> 5840 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5308 conditional = (???*0* === (null | ???*1* | ???*2* | ???*5*)) +5837 -> 5843 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[0] +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["alternate"] +- *3* t + ⚠️ pattern without value + +5836 -> 5848 conditional = ( + | (22 !== (???*0* | ???*4*)) + | (23 !== (???*6* | ???*10*)) + | (null === (???*12* | ???*16*)) + | ((???*18* | ???*21* | ???*22*) === ???*23*) + | (null !== (???*24* | ???*28*)) +) +- *0* ???*1*["tag"] ⚠️ unknown object -- *3* ???*4*["current"] +- *1* ???*2*[(g + 1)] + ⚠️ unknown object +- *2* ???*3*["updateQueue"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["tag"] ⚠️ unknown object -- *4* a - ⚠️ circular variable reference -- *5* unknown new expression ⚠️ This value might have side effects - -0 -> 5309 call = (...) => (0 | b | d)(???*0*, (???*1* ? (0 | ???*8*) : 0)) -- *0* arguments[0] +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* ???*7*["tag"] + ⚠️ unknown object +- *7* ???*8*[(g + 1)] + ⚠️ unknown object +- *8* ???*9*["updateQueue"] + ⚠️ unknown object +- *9* arguments[0] ⚠️ function calls are not analysed yet -- *1* (???*2* === (null | ???*3* | ???*4* | ???*7*)) - ⚠️ nested operation -- *2* arguments[0] +- *10* ???*11*["tag"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *11* unsupported expression + ⚠️ This value might have side effects +- *12* ???*13*["memoizedState"] + ⚠️ unknown object +- *13* ???*14*[(g + 1)] + ⚠️ unknown object +- *14* ???*15*["updateQueue"] + ⚠️ unknown object +- *15* arguments[0] ⚠️ function calls are not analysed yet -- *3* arguments[0] +- *16* ???*17*["memoizedState"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *17* unsupported expression + ⚠️ This value might have side effects +- *18* ???*19*[(g + 1)] + ⚠️ unknown object +- *19* ???*20*["updateQueue"] + ⚠️ unknown object +- *20* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["alternate"] +- *21* unsupported expression + ⚠️ This value might have side effects +- *22* arguments[0] + ⚠️ function calls are not analysed yet +- *23* arguments[0] + ⚠️ function calls are not analysed yet +- *24* ???*25*["child"] ⚠️ unknown object -- *5* ???*6*["current"] +- *25* ???*26*[(g + 1)] + ⚠️ unknown object +- *26* ???*27*["updateQueue"] + ⚠️ unknown object +- *27* arguments[0] + ⚠️ function calls are not analysed yet +- *28* ???*29*["child"] ⚠️ unknown object -- *6* a - ⚠️ circular variable reference -- *7* unknown new expression ⚠️ This value might have side effects -- *8* unsupported expression +- *29* unsupported expression ⚠️ This value might have side effects -0 -> 5311 conditional = ???*0* +0 -> 5860 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -5311 -> 5312 call = (...) => T(???*0*, ???*1*) +0 -> 5861 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects -5311 -> 5313 call = (...) => ((null === a) ? ai : a)() +0 -> 5862 call = (...) => undefined(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5311 -> 5314 conditional = ???*0* +0 -> 5863 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -5314 -> 5315 call = module["unstable_now"]() - -5314 -> 5316 call = (...) => a(???*0*, ???*1*) +0 -> 5864 call = (...) => undefined(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects -5311 -> 5317 call = (...) => undefined() - -5311 -> 5318 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] +0 -> 5867 call = (...) => ((5 === a["tag"]) || (3 === a["tag"]) || (4 === a["tag"]))(???*0*) +- *0* ???*1*["return"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *1* h - ⚠️ pattern without value -5311 -> 5319 call = (...) => undefined() +0 -> 5869 free var = FreeVar(Error) -5311 -> 5321 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 5870 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(160) -0 -> 5322 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 5871 call = ???*0*( + `Minified React error #${160}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${160}` + ⚠️ nested operation -5322 -> 5323 call = (...) => ((0 !== a) ? a : (???*0* ? 1073741824 : 0))(???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* arguments[0] +0 -> 5875 call = (...) => (undefined | FreeVar(undefined))(???*0*, "") +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -5322 -> 5324 call = (...) => a(???*0*, ???*1*) +0 -> 5877 call = (...) => (undefined | null | a["stateNode"])(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -5322 -> 5325 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects -5325 -> 5326 call = (...) => a(???*0*, 0) +0 -> 5878 call = (...) => undefined(???*0*, (undefined | null | ???*1*), ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["stateNode"] + ⚠️ unknown object +- *4* ???*5*["return"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet -5325 -> 5327 call = (...) => undefined(???*0*, ???*1*) +0 -> 5881 call = (...) => (undefined | null | a["stateNode"])(???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -5325 -> 5328 call = module["unstable_now"]() -5325 -> 5329 call = (...) => undefined(???*0*, module["unstable_now"]()) +0 -> 5882 call = (...) => undefined(???*0*, (undefined | null | ???*1*), ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["containerInfo"] + ⚠️ unknown object +- *4* ???*5*["stateNode"] + ⚠️ unknown object +- *5* ???*6*["return"] + ⚠️ unknown object +- *6* arguments[0] + ⚠️ function calls are not analysed yet -5322 -> 5330 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 5883 free var = FreeVar(Error) -5330 -> 5331 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 5884 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(161) -5330 -> 5334 call = (...) => (!(1) | !(0))(???*0*) -- *0* max number of linking steps reached +0 -> 5885 call = ???*0*( + `Minified React error #${161}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${161}` + ⚠️ nested operation -5330 -> 5335 call = (...) => T(???*0*, ???*1*) +0 -> 5887 call = (...) => undefined(???*0*, ???*1*, ???*3*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -5330 -> 5336 call = (...) => ((0 !== a) ? a : (???*0* ? 1073741824 : 0))(???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* arguments[0] +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet +- *3* k + ⚠️ pattern without value -5330 -> 5337 call = (...) => a( - ???*0*, - ( - | (???*1* ? { - "readContext": (...) => b, - "useCallback": (...) => undefined, - "useContext": (...) => undefined, - "useEffect": (...) => undefined, - "useImperativeHandle": (...) => undefined, - "useInsertionEffect": (...) => undefined, - "useLayoutEffect": (...) => undefined, - "useMemo": (...) => undefined, - "useReducer": (...) => undefined, - "useRef": (...) => undefined, - "useState": (...) => undefined, - "useDebugValue": (...) => undefined, - "useDeferredValue": (...) => undefined, - "useTransition": (...) => undefined, - "useMutableSource": (...) => undefined, - "useSyncExternalStore": (...) => undefined, - "useId": (...) => undefined, - "unstable_isNewReconciler": false - } : module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"]["current"]) - | (???*2* ? (???*5* | ???*6*) : ???*7*) - | ???*9* - ) -) +0 -> 5890 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* (null === module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"]["current"]) - ⚠️ nested operation -- *2* (0 !== (???*3* | ???*4*)) - ⚠️ nested operation -- *3* arguments[0] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *4* unsupported expression - ⚠️ This value might have side effects -- *5* arguments[0] +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *6* unsupported expression - ⚠️ This value might have side effects -- *7* (???*8* ? 1073741824 : 0) - ⚠️ nested operation -- *8* unsupported expression - ⚠️ This value might have side effects -- *9* unsupported expression - ⚠️ This value might have side effects -5330 -> 5338 conditional = ???*0* +0 -> 5894 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5338 -> 5339 call = (...) => a(???*0*, 0) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -5338 -> 5340 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +5894 -> 5896 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5338 -> 5341 call = module["unstable_now"]() +5896 -> 5899 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5338 -> 5342 call = (...) => undefined(???*0*, module["unstable_now"]()) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +5899 -> 5903 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5330 -> 5345 free var = FreeVar(Error) +5903 -> 5904 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5330 -> 5346 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(345) +5903 -> 5905 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5330 -> 5347 call = ???*0*( - `Minified React error #${345}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +5905 -> 5907 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${345}` - ⚠️ nested operation -5330 -> 5348 call = (...) => null(???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +5896 -> 5908 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet -5330 -> 5349 call = (...) => undefined(???*0*, ???*1*) +5894 -> 5910 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects - -5330 -> 5350 call = module["unstable_now"]() +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet -5330 -> 5351 conditional = ???*0* +5894 -> 5912 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5351 -> 5352 call = (...) => (0 | b | d)(???*0*, 0) +5912 -> 5914 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet -5351 -> 5354 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 5916 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -5354 -> 5355 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +5916 -> 5919 conditional = (0 !== ???*0*) - *0* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* unsupported expression - ⚠️ This value might have side effects -5351 -> 5360 member call = (...) => null["bind"](null, ???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +5919 -> 5921 call = (...) => undefined(5, ???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -5351 -> 5361 call = (???*0* ? ???*3* : ???*4*)(???*5*, ???*6*) -- *0* ("function" === ???*1*) - ⚠️ nested operation -- *1* typeof(???*2*) - ⚠️ nested operation -- *2* FreeVar(setTimeout) - ⚠️ unknown global - ⚠️ This value might have side effects -- *3* FreeVar(setTimeout) - ⚠️ unknown global +5919 -> 5924 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *4* unsupported expression + +5924 -> 5925 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* max number of linking steps reached + +5925 -> 5927 member call = ???*0*["componentDidMount"]() +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *6* max number of linking steps reached + +5925 -> 5930 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5362 call = (...) => null(???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +5930 -> 5934 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5363 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +5925 -> 5938 member call = ???*0*["componentDidUpdate"](???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects - -5330 -> 5365 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) -- *0* ???*1*["clz32"] - ⚠️ unknown object +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *1* FreeVar(Math) - ⚠️ unknown global +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *2* ???*3*["clz32"] - ⚠️ unknown object + +5919 -> 5940 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* FreeVar(Math) - ⚠️ unknown global +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *4* ((0 === a) ? 32 : ???*5*) - ⚠️ nested operation -- *5* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *6* max number of linking steps reached + +5919 -> 5942 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5367 call = module["unstable_now"]() +5942 -> 5944 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5330 -> 5368 call = ???*0*(???*2*) -- *0* ???*1*["ceil"] - ⚠️ unknown object +5942 -> 5951 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* FreeVar(Math) - ⚠️ unknown global +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5371 member call = (...) => null["bind"](null, ???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +5919 -> 5954 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5372 call = (???*0* ? ???*3* : ???*4*)(???*5*, ???*6*) -- *0* ("function" === ???*1*) - ⚠️ nested operation -- *1* typeof(???*2*) - ⚠️ nested operation -- *2* FreeVar(setTimeout) - ⚠️ unknown global - ⚠️ This value might have side effects -- *3* FreeVar(setTimeout) - ⚠️ unknown global - ⚠️ This value might have side effects -- *4* unsupported expression +5954 -> 5959 member call = ???*0*["focus"]() +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* max number of linking steps reached + +5919 -> 5964 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *6* max number of linking steps reached + +5964 -> 5966 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5373 call = (...) => null(???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +5966 -> 5968 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5374 call = (...) => null(???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +5968 -> 5970 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -5330 -> 5375 free var = FreeVar(Error) +5919 -> 5971 free var = FreeVar(Error) -5330 -> 5376 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(329) +5919 -> 5972 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(163) -5330 -> 5377 call = ???*0*( - `Minified React error #${329}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +5919 -> 5973 call = ???*0*( + `Minified React error #${163}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${329}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${163}` ⚠️ nested operation -0 -> 5378 call = module["unstable_now"]() +5916 -> 5975 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5379 call = (...) => undefined(???*0*, module["unstable_now"]()) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +5916 -> 5977 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* r + ⚠️ pattern without value -0 -> 5381 conditional = ???*0* +0 -> 5979 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5381 -> 5383 member call = (...) => ( - | null - | ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) -)["bind"](null, ???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 5984 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 5990 call = (...) => undefined(4, ???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 5991 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* k + ⚠️ pattern without value + +0 -> 5994 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +5994 -> 5997 member call = ???*0*["componentDidMount"]() +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5388 call = (...) => a(???*0*, ???*1*) +5994 -> 5998 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects +- *2* k + ⚠️ pattern without value + +0 -> 6000 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5389 call = (...) => T(???*0*, ???*1*) +0 -> 6001 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects +- *2* k + ⚠️ pattern without value -0 -> 5390 call = (...) => undefined(???*0*) +0 -> 6003 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5391 conditional = ???*0* +0 -> 6004 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* k + ⚠️ pattern without value -5391 -> 5394 member call = ???*0*["apply"](???*1*, ???*2*) +0 -> 6006 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* arguments[0] - ⚠️ function calls are not analysed yet +- *2* k + ⚠️ pattern without value -0 -> 5398 conditional = ((null !== ???*0*) | ???*2*) -- *0* ???*1*["updateQueue"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* (null !== c) - ⚠️ sequence with side effects +0 -> 6008 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5398 -> 5403 call = ???*0*() -- *0* ???*1*["getSnapshot"] - ⚠️ unknown object -- *1* ???*2*[d] - ⚠️ unknown object -- *2* ???*3*["updateQueue"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 6013 free var = FreeVar(Math) -5398 -> 5404 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*(), ???*13*) -- *0* ("function" === ???*1*) +0 -> 6017 call = (...) => {"current": a}(0) + +0 -> 6018 free var = FreeVar(Infinity) + +0 -> 6019 conditional = (0 !== ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects + +6019 -> 6020 call = module["unstable_now"]() + +6019 -> 6021 conditional = (???*0* !== (???*1* | ???*2*)) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* module["unstable_now"]() ⚠️ nested operation -- *1* typeof(???*2*) + +6021 -> 6022 call = module["unstable_now"]() + +0 -> 6023 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6025 conditional = (0 === ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects + +6025 -> 6026 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +6025 -> 6027 conditional = ((0 !== ???*0*) | (0 !== (0 | ???*1*))) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects + +6027 -> 6028 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +6027 -> 6030 conditional = (null !== module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentBatchConfig"]["transition"]) + +6030 -> 6031 call = (...) => a() + +6030 -> 6032 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +6030 -> 6033 conditional = (0 !== (???*0* | 0 | 1 | ???*1* | 4 | ???*2* | ???*7*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* C + ⚠️ circular variable reference +- *2* ((???*3* | ???*5*) ? ???*6* : 4) ⚠️ nested operation -- *2* ???*3*["is"] +- *3* (0 !== ???*4*) + ⚠️ nested operation +- *4* C + ⚠️ circular variable reference +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* C + ⚠️ circular variable reference +- *7* ???*8*["event"] ⚠️ unknown object ⚠️ This value might have side effects -- *3* FreeVar(Object) +- *8* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *4* ???*5*["is"] + +6033 -> 6034 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +6033 -> 6036 free var = FreeVar(window) + +6033 -> 6037 conditional = (???*0* === (???*1* | 0 | 1 | ???*2* | 4 | ???*3* | ???*8*)) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* C + ⚠️ circular variable reference +- *3* ((???*4* | ???*6*) ? ???*7* : 4) + ⚠️ nested operation +- *4* (0 !== ???*5*) + ⚠️ nested operation +- *5* C + ⚠️ circular variable reference +- *6* unsupported expression + ⚠️ This value might have side effects +- *7* C + ⚠️ circular variable reference +- *8* ???*9*["event"] ⚠️ unknown object ⚠️ This value might have side effects -- *5* FreeVar(Object) +- *9* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *6* (((a === b) && ((0 !== a) || (???*7* === ???*8*))) || ((a !== a) && (b !== b))) + +6037 -> 6039 call = (...) => (undefined | 1 | 4 | 16 | 536870912)( + ( + | ???*0* + | 0["type"] + | 1["type"] + | 4["type"] + | ((???*2* | ???*4*) ? ???*5* : 4)["type"] + | (???*6* ? 16 : (???*7* | null | ???*14* | ???*15*))["type"] + | ???*17* + | (???*20* ? 16 : (undefined | 1 | 4 | 16 | 536870912))["type"] + ) +) +- *0* ???*1*["type"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* (0 !== ???*3*) ⚠️ nested operation -- *7* unsupported expression +- *3* C + ⚠️ circular variable reference +- *4* unsupported expression + ⚠️ This value might have side effects +- *5* C + ⚠️ circular variable reference +- *6* unsupported expression ⚠️ This value might have side effects +- *7* (???*8* ? ???*9* : 1) + ⚠️ nested operation - *8* unsupported expression ⚠️ This value might have side effects -- *9* ???*10*["getSnapshot"] - ⚠️ unknown object -- *10* ???*11*[d] - ⚠️ unknown object -- *11* ???*12*["updateQueue"] - ⚠️ unknown object -- *12* arguments[0] - ⚠️ function calls are not analysed yet -- *13* ???*14*[d] - ⚠️ unknown object -- *14* ???*15*["updateQueue"] - ⚠️ unknown object -- *15* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5407 conditional = (???*0* | (null !== ???*1*)) -- *0* unsupported expression +- *9* (???*10* ? ???*11* : 4) + ⚠️ nested operation +- *10* unsupported expression ⚠️ This value might have side effects -- *1* ???*2*["updateQueue"] +- *11* (???*12* ? 16 : 536870912) + ⚠️ nested operation +- *12* (0 !== ???*13*) + ⚠️ nested operation +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* arguments[0] + ⚠️ function calls are not analysed yet +- *15* ???*16*["value"] ⚠️ unknown object -- *2* arguments[0] +- *16* arguments[1] ⚠️ function calls are not analysed yet - -0 -> 5420 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) -- *0* ???*1*["clz32"] +- *17* ???*18*["type"] ⚠️ unknown object ⚠️ This value might have side effects -- *1* FreeVar(Math) - ⚠️ unknown global - ⚠️ This value might have side effects -- *2* ???*3*["clz32"] +- *18* ???*19*["event"] ⚠️ unknown object ⚠️ This value might have side effects -- *3* FreeVar(Math) +- *19* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *4* ((0 === a) ? 32 : ???*5*) +- *20* (???*21* === ???*22*) ⚠️ nested operation -- *5* unsupported expression - ⚠️ This value might have side effects -- *6* arguments[1] - ⚠️ function calls are not analysed yet -- *7* unsupported assign operation +- *21* unsupported expression ⚠️ This value might have side effects +- *22* a + ⚠️ circular variable reference -0 -> 5422 conditional = (0 !== ???*0*) -- *0* unsupported expression +6033 -> 6040 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5422 -> 5423 free var = FreeVar(Error) +0 -> 6041 free var = FreeVar(Error) -5422 -> 5424 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(327) +0 -> 6042 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(185) -5422 -> 5425 call = ???*0*( - `Minified React error #${327}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +0 -> 6043 call = ???*0*( + `Minified React error #${185}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${327}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${185}` ⚠️ nested operation -0 -> 5426 call = (...) => (d | !(1))() - -0 -> 5427 call = (...) => (0 | b | d)(???*0*, 0) +0 -> 6044 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* arguments[3] + ⚠️ function calls are not analysed yet -0 -> 5428 conditional = (0 === ???*0*) +0 -> 6045 conditional = ((0 === ???*0*) | (???*1* !== (null | ???*2* | ???*3* | ???*6*))) - *0* unsupported expression ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["alternate"] + ⚠️ unknown object +- *4* ???*5*["current"] + ⚠️ unknown object +- *5* a + ⚠️ circular variable reference +- *6* unknown new expression + ⚠️ This value might have side effects -5428 -> 5429 call = module["unstable_now"]() +6045 -> 6046 call = (...) => undefined(???*0*, (0 | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* unsupported expression + ⚠️ This value might have side effects -5428 -> 5430 call = (...) => undefined(???*0*, module["unstable_now"]()) +6045 -> 6047 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* arguments[3] + ⚠️ function calls are not analysed yet -0 -> 5431 call = (...) => T( - ???*0*, - ( - | 0 - | ???*1* - | ???*3* - | undefined - | 1 - | 2 - | 4 - | 8 - | 16 - | 32 - | ???*4* - | 134217728 - | 268435456 - | 536870912 - | 1073741824 - | (???*5* ? (???*8* | ???*9*) : ???*10*) - ) -) +6045 -> 6049 call = module["unstable_now"]() + +6045 -> 6050 call = (...) => null() + +0 -> 6052 call = (...) => undefined(???*0*, (???*1* | ???*2*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["entangledLanes"] +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* unsupported expression + ⚠️ This value might have side effects + +0 -> 6053 conditional = (???*0* === (null | ???*1* | ???*2* | ???*5*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["alternate"] + ⚠️ unknown object +- *3* ???*4*["current"] ⚠️ unknown object +- *4* a + ⚠️ circular variable reference +- *5* unknown new expression + ⚠️ This value might have side effects + +0 -> 6054 call = (...) => (0 | b | d)(???*0*, (???*1* ? (0 | ???*8*) : 0)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* (???*2* === (null | ???*3* | ???*4* | ???*7*)) + ⚠️ nested operation - *2* arguments[0] ⚠️ function calls are not analysed yet -- *3* unsupported assign operation +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["alternate"] + ⚠️ unknown object +- *5* ???*6*["current"] + ⚠️ unknown object +- *6* a + ⚠️ circular variable reference +- *7* unknown new expression ⚠️ This value might have side effects -- *4* unsupported expression +- *8* unsupported expression ⚠️ This value might have side effects -- *5* (0 !== (???*6* | ???*7*)) + +0 -> 6055 conditional = (0 === ( + | 0 + | ???*0* + | ???*9* + | ???*11* + | undefined + | 1 + | 2 + | 4 + | 8 + | 16 + | 32 + | ???*12* + | 134217728 + | 268435456 + | 536870912 + | 1073741824 +)) +- *0* (???*1* ? (0 | ???*8*) : 0) ⚠️ nested operation -- *6* arguments[0] +- *1* (???*2* === (null | ???*3* | ???*4* | ???*7*)) + ⚠️ nested operation +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *7* unsupported expression +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["alternate"] + ⚠️ unknown object +- *5* ???*6*["current"] + ⚠️ unknown object +- *6* a + ⚠️ circular variable reference +- *7* unknown new expression ⚠️ This value might have side effects -- *8* arguments[0] +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* ???*10*["entangledLanes"] + ⚠️ unknown object +- *10* arguments[0] ⚠️ function calls are not analysed yet -- *9* unsupported expression +- *11* unsupported assign operation ⚠️ This value might have side effects -- *10* (???*11* ? 1073741824 : 0) - ⚠️ nested operation -- *11* unsupported expression +- *12* unsupported expression ⚠️ This value might have side effects -0 -> 5433 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6055 -> 6056 call = module["unstable_cancelCallback"]( + ( + | ???*0* + | null + | module["unstable_ImmediatePriority"] + | module["unstable_UserBlockingPriority"] + | module["unstable_NormalPriority"] + | module["unstable_IdlePriority"] + | module["unstable_scheduleCallback"](???*2*, ???*3*) + ) +) +- *0* ???*1*["callbackNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* c + ⚠️ circular variable reference +- *3* (...) => (null | ???*4*)["bind"](null, ???*5*) + ⚠️ nested operation +- *4* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) + ⚠️ nested operation +- *5* arguments[0] + ⚠️ function calls are not analysed yet -5433 -> 5434 call = (...) => ((0 !== a) ? a : (???*0* ? 1073741824 : 0))(???*1*) -- *0* unsupported expression +6055 -> 6060 call = module["unstable_cancelCallback"]( + ( + | ???*0* + | null + | module["unstable_ImmediatePriority"] + | module["unstable_UserBlockingPriority"] + | module["unstable_NormalPriority"] + | module["unstable_IdlePriority"] + | module["unstable_scheduleCallback"](???*2*, ???*3*) + ) +) +- *0* ???*1*["callbackNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* c + ⚠️ circular variable reference +- *3* (...) => (null | ???*4*)["bind"](null, ???*5*) + ⚠️ nested operation +- *4* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) + ⚠️ nested operation +- *5* arguments[0] + ⚠️ function calls are not analysed yet + +6055 -> 6061 conditional = (1 === (???*0* | ???*1*)) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* unsupported expression ⚠️ This value might have side effects + +6061 -> 6063 conditional = (0 === ???*0*) +- *0* ???*1*["tag"] + ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet -5433 -> 5435 call = (...) => a(???*0*, (???*1* ? (???*4* | ???*5*) : ???*6*)) +6063 -> 6065 member call = (...) => null["bind"](null, ???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +6063 -> 6066 call = (...) => undefined((...) => null["bind"](null, ???*0*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +6063 -> 6068 member call = (...) => null["bind"](null, ???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +6063 -> 6069 call = (...) => undefined((...) => null["bind"](null, ???*0*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* (0 !== (???*2* | ???*3*)) + +6061 -> 6070 call = (???*0* ? ???*3* : ???*4*)((...) => undefined) +- *0* ("function" === ???*1*) ⚠️ nested operation -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* unsupported expression +- *1* typeof(???*2*) + ⚠️ nested operation +- *2* FreeVar(queueMicrotask) + ⚠️ unknown global ⚠️ This value might have side effects -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* unsupported expression +- *3* FreeVar(queueMicrotask) + ⚠️ unknown global ⚠️ This value might have side effects -- *6* (???*7* ? 1073741824 : 0) +- *4* (???*5* ? (...) => ???*11* : ???*12*) ⚠️ nested operation -- *7* unsupported expression +- *5* ("undefined" !== ???*6*) + ⚠️ nested operation +- *6* typeof(???*7*) + ⚠️ nested operation +- *7* (???*8* ? ???*9* : ???*10*) + ⚠️ nested operation +- *8* ("function" === ???) + ⚠️ nested operation +- *9* FreeVar(Promise) + ⚠️ unknown global ⚠️ This value might have side effects - -0 -> 5436 conditional = ???*0* -- *0* max number of linking steps reached +- *10* unsupported expression + ⚠️ This value might have side effects +- *11* Hf["resolve"](null)["then"](a)["catch"](If) + ⚠️ nested operation +- *12* (???*13* ? ???*16* : ???*17*) + ⚠️ nested operation +- *13* ("function" === ???*14*) + ⚠️ nested operation +- *14* typeof(???*15*) + ⚠️ nested operation +- *15* FreeVar(setTimeout) + ⚠️ unknown global + ⚠️ This value might have side effects +- *16* FreeVar(setTimeout) + ⚠️ unknown global + ⚠️ This value might have side effects +- *17* unsupported expression ⚠️ This value might have side effects -5436 -> 5437 call = (...) => a(???*0*, 0) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +6070 -> 6071 call = (...) => null() -5436 -> 5438 call = (...) => undefined( - ???*0*, +6061 -> 6072 call = (...) => (???*0* ? (???*1* ? ((0 !== ???*2*) ? 16 : 536870912) : 4) : 1)( ( | 0 - | ???*1* - | ???*3* + | (???*3* ? (0 | ???*10*) : 0) + | ???*11* + | ???*13* | undefined | 1 | 2 @@ -31569,1394 +35490,1099 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` | 8 | 16 | 32 - | ???*4* + | ???*14* | 134217728 | 268435456 | 536870912 | 1073741824 - | (???*5* ? (???*8* | ???*9*) : ???*10*) ) ) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["entangledLanes"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* unsupported assign operation +- *0* unsupported expression ⚠️ This value might have side effects -- *4* unsupported expression +- *1* unsupported expression ⚠️ This value might have side effects -- *5* (0 !== (???*6* | ???*7*)) +- *2* unsupported expression + ⚠️ This value might have side effects +- *3* (???*4* === (null | ???*5* | ???*6* | ???*9*)) ⚠️ nested operation -- *6* arguments[0] +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *7* unsupported expression +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["alternate"] + ⚠️ unknown object +- *7* ???*8*["current"] + ⚠️ unknown object +- *8* a + ⚠️ circular variable reference +- *9* unknown new expression ⚠️ This value might have side effects -- *8* arguments[0] +- *10* unsupported expression + ⚠️ This value might have side effects +- *11* ???*12*["entangledLanes"] + ⚠️ unknown object +- *12* arguments[0] ⚠️ function calls are not analysed yet -- *9* unsupported expression +- *13* unsupported assign operation ⚠️ This value might have side effects -- *10* (???*11* ? 1073741824 : 0) - ⚠️ nested operation -- *11* unsupported expression +- *14* unsupported expression ⚠️ This value might have side effects -5436 -> 5439 call = module["unstable_now"]() - -5436 -> 5440 call = (...) => undefined(???*0*, module["unstable_now"]()) +6061 -> 6074 member call = (...) => ( + | null + | ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) +)["bind"](null, ???*0*) - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 5441 conditional = ???*0* -- *0* max number of linking steps reached +6061 -> 6075 call = (...) => ac(a, b)( + ( + | ???*0* + | null + | module["unstable_ImmediatePriority"] + | module["unstable_UserBlockingPriority"] + | module["unstable_NormalPriority"] + | module["unstable_IdlePriority"] + | module["unstable_scheduleCallback"](???*2*, ???*3*) + ), + (...) => (null | ???*6*)["bind"](null, ???*7*) +) +- *0* ???*1*["callbackNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* c + ⚠️ circular variable reference +- *3* (...) => (null | ???*4*)["bind"](null, ???*5*) + ⚠️ nested operation +- *4* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) + ⚠️ nested operation +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) + ⚠️ nested operation +- *7* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 6078 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -5441 -> 5442 free var = FreeVar(Error) +6078 -> 6079 free var = FreeVar(Error) -5441 -> 5443 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(345) +6078 -> 6080 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(327) -5441 -> 5444 call = ???*0*( - `Minified React error #${345}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6078 -> 6081 call = ???*0*( + `Minified React error #${327}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${345}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${327}` ⚠️ nested operation -0 -> 5449 call = (...) => null(???*0*, ???*1*, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6083 call = (...) => (d | !(1))() -0 -> 5450 call = module["unstable_now"]() +0 -> 6085 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5451 call = (...) => undefined(???*0*, module["unstable_now"]()) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +6085 -> 6086 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 5452 call = ???*0*(???*1*) +6085 -> 6087 conditional = (???*0* === (null | ???*1* | ???*2* | ???*5*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[1] +- *1* arguments[0] ⚠️ function calls are not analysed yet +- *2* ???*3*["alternate"] + ⚠️ unknown object +- *3* ???*4*["current"] + ⚠️ unknown object +- *4* a + ⚠️ circular variable reference +- *5* unknown new expression + ⚠️ This value might have side effects -0 -> 5453 call = module["unstable_now"]() - -0 -> 5454 call = (...) => null() - -0 -> 5456 call = (...) => (d | !(1))() - -0 -> 5459 call = ???*0*() +6085 -> 6088 call = (...) => (0 | b | d)(???*0*, (???*1* ? (0 | ???*8*) : 0)) - *0* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 5461 call = (...) => null() - -0 -> 5463 call = (...) => undefined({"current": 0}) - -0 -> 5468 call = (???*0* ? ???*3* : ???*4*)(???*5*) -- *0* ("function" === ???*1*) - ⚠️ nested operation -- *1* typeof(???*2*) +- *1* (???*2* === (null | ???*3* | ???*4* | ???*7*)) ⚠️ nested operation -- *2* FreeVar(clearTimeout) - ⚠️ unknown global - ⚠️ This value might have side effects -- *3* FreeVar(clearTimeout) - ⚠️ unknown global - ⚠️ This value might have side effects -- *4* unsupported expression +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["alternate"] + ⚠️ unknown object +- *5* ???*6*["current"] + ⚠️ unknown object +- *6* a + ⚠️ circular variable reference +- *7* unknown new expression ⚠️ This value might have side effects -- *5* max number of linking steps reached +- *8* unsupported expression ⚠️ This value might have side effects -0 -> 5469 conditional = ???*0* +6085 -> 6089 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5469 -> 5471 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +6089 -> 6090 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5469 -> 5475 call = (...) => undefined() - -5469 -> 5476 call = (...) => undefined() - -5469 -> 5477 call = (...) => undefined({"current": false}) - -5469 -> 5478 call = (...) => undefined({"current": {}}) - -5469 -> 5479 call = (...) => undefined() - -5469 -> 5480 call = (...) => undefined(???*0*) +6089 -> 6092 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5469 -> 5481 call = (...) => undefined() - -5469 -> 5482 call = (...) => undefined({"current": 0}) +6092 -> 6093 call = (...) => T(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* max number of linking steps reached + ⚠️ This value might have side effects -5469 -> 5483 call = (...) => undefined({"current": 0}) +6092 -> 6094 call = (...) => ((null === a) ? ai : a)() -5469 -> 5486 call = (...) => undefined(???*0*) +6092 -> 6095 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5469 -> 5487 call = (...) => undefined() +6095 -> 6096 call = module["unstable_now"]() -0 -> 5490 call = (...) => c((???*0* | ???*2*), null) -- *0* ???*1*["current"] - ⚠️ unknown object -- *1* arguments[0] +6095 -> 6097 call = (...) => a(???*0*, ???*1*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["current"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5491 conditional = (null !== (null | [???*0*])) +6092 -> 6098 call = (...) => undefined() + +6092 -> 6099 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet +- *1* h + ⚠️ pattern without value -5491 -> 5498 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 5503 call = (...) => undefined() - -0 -> 5505 conditional = (false | true) +6092 -> 6100 call = (...) => undefined() -0 -> 5515 conditional = ???*0* +6092 -> 6102 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5515 -> 5518 conditional = ???*0* +6089 -> 6103 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5518 -> 5520 conditional = ???*0* -- *0* max number of linking steps reached +6103 -> 6104 call = (...) => ((0 !== a) ? a : (???*0* ? 1073741824 : 0))(???*1*) +- *0* unsupported expression ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -5515 -> 5529 call = (...) => (a | null)(???*0*) -- *0* max number of linking steps reached +6103 -> 6105 call = (...) => a(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* max number of linking steps reached ⚠️ This value might have side effects -5515 -> 5530 conditional = ???*0* +6103 -> 6106 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5530 -> 5532 call = (...) => (???*0* | a)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) -- *0* a - ⚠️ sequence with side effects - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects -- *5* max number of linking steps reached - ⚠️ This value might have side effects +6106 -> 6107 call = (...) => a(???*0*, 0) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5530 -> 5534 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6106 -> 6108 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -5530 -> 5536 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6106 -> 6109 call = module["unstable_now"]() -5536 -> 5537 free var = FreeVar(Set) +6106 -> 6110 call = (...) => undefined(???*0*, module["unstable_now"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5536 -> 5539 member call = ???*0*["add"](???*1*) -- *0* unknown new expression +6103 -> 6111 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects + +6111 -> 6112 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -5536 -> 5542 member call = ???*0*["add"](???*1*) +6111 -> 6115 call = (...) => (!(1) | !(0))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects + +6111 -> 6116 call = (...) => T(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -5530 -> 5543 conditional = (0 === ???*0*) +6111 -> 6117 call = (...) => ((0 !== a) ? a : (???*0* ? 1073741824 : 0))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +6111 -> 6118 call = (...) => a( + ???*0*, + ( + | (???*1* ? { + "readContext": (...) => b, + "useCallback": (...) => undefined, + "useContext": (...) => undefined, + "useEffect": (...) => undefined, + "useImperativeHandle": (...) => undefined, + "useInsertionEffect": (...) => undefined, + "useLayoutEffect": (...) => undefined, + "useMemo": (...) => undefined, + "useReducer": (...) => undefined, + "useRef": (...) => undefined, + "useState": (...) => undefined, + "useDebugValue": (...) => undefined, + "useDeferredValue": (...) => undefined, + "useTransition": (...) => undefined, + "useMutableSource": (...) => undefined, + "useSyncExternalStore": (...) => undefined, + "useId": (...) => undefined, + "unstable_isNewReconciler": false + } : module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"]["current"]) + | (???*2* ? (???*5* | ???*6*) : ???*7*) + | ???*9* + ) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* (null === module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"]["current"]) + ⚠️ nested operation +- *2* (0 !== (???*3* | ???*4*)) + ⚠️ nested operation +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* unsupported expression + ⚠️ This value might have side effects +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* unsupported expression + ⚠️ This value might have side effects +- *7* (???*8* ? 1073741824 : 0) + ⚠️ nested operation +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* unsupported expression + ⚠️ This value might have side effects -5543 -> 5544 call = (...) => undefined(???*0*, ???*1*, ???*2*) +6111 -> 6119 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects + +6119 -> 6120 call = (...) => a(???*0*, 0) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +6119 -> 6121 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -5543 -> 5545 call = (...) => undefined() +6119 -> 6122 call = module["unstable_now"]() + +6119 -> 6123 call = (...) => undefined(???*0*, module["unstable_now"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5530 -> 5546 free var = FreeVar(Error) +6111 -> 6126 free var = FreeVar(Error) -5530 -> 5547 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(426) +6111 -> 6127 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(345) -5530 -> 5548 call = ???*0*( - `Minified React error #${426}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6111 -> 6128 call = ???*0*( + `Minified React error #${345}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${426}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${345}` ⚠️ nested operation -5515 -> 5550 conditional = (false | true | ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -5550 -> 5551 call = (...) => (a | null)(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5550 -> 5552 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5552 -> 5555 call = (...) => (???*0* | a)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) -- *0* a - ⚠️ sequence with side effects - ⚠️ This value might have side effects +6111 -> 6129 call = (...) => null(???*0*, ???*1*, null) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects -- *5* max number of linking steps reached - ⚠️ This value might have side effects -5552 -> 5556 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6111 -> 6130 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -5552 -> 5557 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6111 -> 6131 call = module["unstable_now"]() -0 -> 5558 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) +6111 -> 6132 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5559 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6132 -> 6133 call = (...) => (0 | b | d)(???*0*, 0) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5559 -> 5561 member call = ???*0*["push"](???*1*) +6132 -> 6135 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5565 call = (...) => c(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +6135 -> 6136 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *1* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *2* unsupported expression ⚠️ This value might have side effects -0 -> 5566 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6132 -> 6141 member call = (...) => null["bind"](null, ???*0*, ???*1*, null) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5573 member call = (???*0* | null)["has"](???*1*) -- *0* unknown new expression - ⚠️ This value might have side effects -- *1* max number of linking steps reached +6132 -> 6142 call = (???*0* ? ???*3* : ???*4*)(???*5*, ???*6*) +- *0* ("function" === ???*1*) + ⚠️ nested operation +- *1* typeof(???*2*) + ⚠️ nested operation +- *2* FreeVar(setTimeout) + ⚠️ unknown global ⚠️ This value might have side effects - -0 -> 5574 conditional = ???*0* -- *0* max number of linking steps reached +- *3* FreeVar(setTimeout) + ⚠️ unknown global ⚠️ This value might have side effects - -5574 -> 5577 call = (...) => c(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +- *4* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *5* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *6* max number of linking steps reached ⚠️ This value might have side effects -5574 -> 5578 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6111 -> 6143 call = (...) => null(???*0*, ???*1*, null) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5580 call = (...) => (undefined | FreeVar(undefined))(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 5584 conditional = (null === module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"]["current"]) - -0 -> 5585 call = (...) => undefined((null | ???*0* | ???*1* | ???*4*), (0 | ???*5*)) +6111 -> 6144 call = (...) => undefined(???*0*, ???*1*) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["alternate"] - ⚠️ unknown object -- *2* ???*3*["current"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference -- *4* unknown new expression - ⚠️ This value might have side effects -- *5* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5586 call = (...) => ((null === a) ? ai : a)() - -0 -> 5587 conditional = (((null | ???*0* | ???*1* | ???*4*) !== ???*5*) | ((0 | ???*6*) !== ???*7*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["alternate"] - ⚠️ unknown object -- *2* ???*3*["current"] +6111 -> 6146 call = (???*0* ? ???*2* : (...) => ???*4*)(???*6*) +- *0* ???*1*["clz32"] ⚠️ unknown object -- *3* a - ⚠️ circular variable reference -- *4* unknown new expression ⚠️ This value might have side effects -- *5* arguments[0] - ⚠️ function calls are not analysed yet -- *6* unsupported expression +- *1* FreeVar(Math) + ⚠️ unknown global ⚠️ This value might have side effects -- *7* arguments[1] - ⚠️ function calls are not analysed yet - -5587 -> 5588 call = (...) => a(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 5589 call = (...) => undefined() - -0 -> 5590 call = (...) => undefined(???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* e - ⚠️ pattern without value - -0 -> 5591 call = (...) => undefined() - -0 -> 5593 conditional = ???*0* -- *0* max number of linking steps reached +- *2* ???*3*["clz32"] + ⚠️ unknown object ⚠️ This value might have side effects - -5593 -> 5594 free var = FreeVar(Error) - -5593 -> 5595 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(261) - -5593 -> 5596 call = ???*0*( - `Minified React error #${261}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) +- *3* FreeVar(Math) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${261}` +- *4* ((0 === a) ? 32 : ???*5*) ⚠️ nested operation - -0 -> 5597 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +- *5* unsupported expression ⚠️ This value might have side effects - -0 -> 5598 call = module["unstable_shouldYield"]() - -0 -> 5599 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +- *6* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5601 call = ( - | ???*0* - | (...) => ( - | undefined - | ???*1* - | b - | null - | pj(a, b, c) - | b["child"] - | cj(a, b, b["type"], b["pendingProps"], c) - | yj(a, b, c) - | ej(a, b, c) - ) -)(???*2*, ???*4*, (???*5* | 0 | ???*6* | ???*7* | ???*8*)) -- *0* Wk - ⚠️ pattern without value -- *1* zj(a, b, c) - ⚠️ sequence with side effects - ⚠️ This value might have side effects -- *2* ???*3*["alternate"] +6111 -> 6148 call = module["unstable_now"]() + +6111 -> 6149 call = ???*0*(???*2*) +- *0* ???*1*["ceil"] ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* unsupported assign operation ⚠️ This value might have side effects -- *6* unknown mutation +- *1* FreeVar(Math) + ⚠️ unknown global ⚠️ This value might have side effects -- *7* arguments[1] +- *2* unsupported expression + ⚠️ This value might have side effects + +6111 -> 6152 member call = (...) => null["bind"](null, ???*0*, ???*1*, null) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *8* updated with update expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5604 conditional = (null === ???*0*) -- *0* ( - | ???*1* - | (...) => ( - | undefined - | ???*2* - | b - | null - | pj(a, b, c) - | b["child"] - | cj(a, b, b["type"], b["pendingProps"], c) - | yj(a, b, c) - | ej(a, b, c) - ) - )(a["alternate"], a, gj) - ⚠️ non-function callee -- *1* Wk - ⚠️ pattern without value -- *2* zj(a, b, c) - ⚠️ sequence with side effects +6111 -> 6153 call = (???*0* ? ???*3* : ???*4*)(???*5*, ???*6*) +- *0* ("function" === ???*1*) + ⚠️ nested operation +- *1* typeof(???*2*) + ⚠️ nested operation +- *2* FreeVar(setTimeout) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* FreeVar(setTimeout) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* unsupported expression + ⚠️ This value might have side effects +- *5* max number of linking steps reached + ⚠️ This value might have side effects +- *6* max number of linking steps reached ⚠️ This value might have side effects -5604 -> 5605 call = (...) => (undefined | FreeVar(undefined))(???*0*) +6111 -> 6154 call = (...) => null(???*0*, ???*1*, null) - *0* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 5610 conditional = (0 === ???*0*) -- *0* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -5610 -> 5611 call = (...) => (undefined | null | (???*0* ? b : null) | ???*1* | b["child"])(???*2*, (???*3* | ???*4*), (???*6* | 0 | ???*7* | ???*8* | ???*9*)) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* b - ⚠️ sequence with side effects +6111 -> 6155 call = (...) => null(???*0*, ???*1*, null) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached + +6111 -> 6156 free var = FreeVar(Error) + +6111 -> 6157 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(329) + +6111 -> 6158 call = ???*0*( + `Minified React error #${329}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *3* arguments[0] +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${329}` + ⚠️ nested operation + +6089 -> 6159 call = module["unstable_now"]() + +6089 -> 6160 call = (...) => undefined(???*0*, module["unstable_now"]()) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["return"] - ⚠️ unknown object -- *5* b - ⚠️ circular variable reference -- *6* unsupported assign operation - ⚠️ This value might have side effects -- *7* unknown mutation + +6089 -> 6162 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *8* arguments[1] + +6162 -> 6164 member call = (...) => ( + | null + | ((a["callbackNode"] === c) ? Hk["bind"](null, a) : null) +)["bind"](null, ???*0*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *9* updated with update expression + +6089 -> 6165 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5610 -> 5612 call = (...) => (undefined | ???*0* | null | (???*3* ? ???*4* : null))(???*5*, (???*6* | ???*7*)) -- *0* (???*1* ? ???*2* : null) - ⚠️ sequence with side effects +0 -> 6170 call = (...) => a(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* b - ⚠️ sequence with side effects + +0 -> 6171 call = (...) => T(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *4* b - ⚠️ sequence with side effects + +0 -> 6172 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* max number of linking steps reached + +0 -> 6173 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *6* arguments[0] - ⚠️ function calls are not analysed yet -- *7* ???*8*["return"] - ⚠️ unknown object -- *8* b - ⚠️ circular variable reference -5610 -> 5613 conditional = ???*0* +0 -> 6174 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5610 -> 5615 conditional = (null !== (???*0* | ???*1*)) -- *0* arguments[0] +6174 -> 6177 member call = ???*0*["apply"](???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["return"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -0 -> 5622 call = (...) => null( - ???*0*, - ???*1*, - ???*2*, - ( - | 0 - | 1 - | ???*3* - | 4 - | ((???*4* | ???*6*) ? ???*7* : 4) - | (???*8* ? 16 : (???*9* | null | ???*16* | ???*17*)) - | ???*19* - ) -) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] +0 -> 6181 conditional = ((null !== ???*0*) | ???*2*) +- *0* ???*1*["updateQueue"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* arguments[2] +- *2* (null !== c) + ⚠️ sequence with side effects + ⚠️ This value might have side effects + +6181 -> 6186 call = ???*0*() +- *0* ???*1*["getSnapshot"] + ⚠️ unknown object +- *1* ???*2*[d] + ⚠️ unknown object +- *2* ???*3*["updateQueue"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *3* C - ⚠️ circular variable reference -- *4* (0 !== ???*5*) + +6181 -> 6187 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*(), ???*13*) +- *0* ("function" === ???*1*) ⚠️ nested operation -- *5* C - ⚠️ circular variable reference -- *6* unsupported expression +- *1* typeof(???*2*) + ⚠️ nested operation +- *2* ???*3*["is"] + ⚠️ unknown object ⚠️ This value might have side effects -- *7* C - ⚠️ circular variable reference -- *8* unsupported expression +- *3* FreeVar(Object) + ⚠️ unknown global ⚠️ This value might have side effects -- *9* (???*10* ? ???*11* : 1) - ⚠️ nested operation -- *10* unsupported expression +- *4* ???*5*["is"] + ⚠️ unknown object ⚠️ This value might have side effects -- *11* (???*12* ? ???*13* : 4) - ⚠️ nested operation -- *12* unsupported expression +- *5* FreeVar(Object) + ⚠️ unknown global ⚠️ This value might have side effects -- *13* (???*14* ? 16 : 536870912) - ⚠️ nested operation -- *14* (0 !== ???*15*) +- *6* (((a === b) && ((0 !== a) || (???*7* === ???*8*))) || ((a !== a) && (b !== b))) ⚠️ nested operation -- *15* unsupported expression +- *7* unsupported expression ⚠️ This value might have side effects -- *16* arguments[0] - ⚠️ function calls are not analysed yet -- *17* ???*18*["value"] +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* ???*10*["getSnapshot"] ⚠️ unknown object -- *18* arguments[1] +- *10* ???*11*[d] + ⚠️ unknown object +- *11* ???*12*["updateQueue"] + ⚠️ unknown object +- *12* arguments[0] ⚠️ function calls are not analysed yet -- *19* arguments[0] +- *13* ???*14*[d] + ⚠️ unknown object +- *14* ???*15*["updateQueue"] + ⚠️ unknown object +- *15* arguments[0] ⚠️ function calls are not analysed yet -0 -> 5624 call = (...) => (d | !(1))() - -0 -> 5625 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -5625 -> 5626 free var = FreeVar(Error) - -5625 -> 5627 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(327) - -5625 -> 5628 call = ???*0*( - `Minified React error #${327}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${327}` +6181 -> 6188 conditional = !(???*0*) +- *0* ???*1*(???*10*, ???*14*) + ⚠️ unknown callee +- *1* (???*2* ? ???*5* : (...) => ???*7*) ⚠️ nested operation - -0 -> 5634 conditional = ((???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*) === (???*4* | null["current"])) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["finishedWork"] +- *2* ("function" === ???*3*) + ⚠️ nested operation +- *3* typeof(???*4*) + ⚠️ nested operation +- *4* ???["is"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* updated with update expression ⚠️ This value might have side effects -- *4* ???*5*["current"] +- *5* ???*6*["is"] ⚠️ unknown object -- *5* arguments[0] - ⚠️ function calls are not analysed yet - -5634 -> 5635 free var = FreeVar(Error) - -5634 -> 5636 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(177) - -5634 -> 5637 call = ???*0*( - `Minified React error #${177}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) + ⚠️ This value might have side effects +- *6* FreeVar(Object) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${177}` +- *7* (((a === b) && ((0 !== a) || (???*8* === ???*9*))) || ((a !== a) && (b !== b))) ⚠️ nested operation - -0 -> 5642 call = (...) => undefined( - (???*0* | ???*1* | null), - ( - | ???*3* - | (0 !== ???*4*) - | module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentBatchConfig"]["transition"] - | ???*5* - | null["pendingLanes"] - ) -) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["value"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* unsupported expression +- *8* unsupported expression ⚠️ This value might have side effects -- *4* unsupported expression +- *9* unsupported expression ⚠️ This value might have side effects -- *5* ???*6*["pendingLanes"] +- *10* ???*11*() + ⚠️ nested operation +- *11* ???*12*["getSnapshot"] ⚠️ unknown object -- *6* arguments[0] +- *12* ???*13*[d] + ⚠️ unknown object +- *13* ???["updateQueue"] + ⚠️ unknown object +- *14* ???*15*[d] + ⚠️ unknown object +- *15* ???*16*["updateQueue"] + ⚠️ unknown object +- *16* arguments[0] ⚠️ function calls are not analysed yet -0 -> 5645 call = (...) => ac(a, b)(module["unstable_NormalPriority"], (...) => null) +6188 -> 6189 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -5645 -> 5646 call = (...) => (d | !(1))() +6181 -> 6190 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 5649 conditional = ( - | (0 !== ???*0*) - | ???*1* - | module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentBatchConfig"]["transition"] - | ???*2* - | null["pendingLanes"] -) +0 -> 6193 conditional = (???*0* | (null !== ???*1*)) - *0* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* ???*3*["pendingLanes"] +- *1* ???*2*["updateQueue"] ⚠️ unknown object -- *3* arguments[0] +- *2* arguments[0] ⚠️ function calls are not analysed yet -5649 -> 5653 call = (...) => n( - (???*0* | ???*1* | null), - (???*3* | ???*4* | null["finishedWork"] | 0 | ???*6*) -) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["value"] +6193 -> 6198 conditional = ((null === ???*0*) | (???*2* === ???*4*)) +- *0* ???*1*["return"] ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* arguments[2] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["finishedWork"] +- *2* ???*3*["return"] ⚠️ unknown object -- *5* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *6* updated with update expression +- *4* arguments[0] + ⚠️ function calls are not analysed yet + +6198 -> 6199 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5649 -> 5654 call = (...) => undefined( - (???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*), - (???*4* | ???*5* | null) -) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["finishedWork"] +0 -> 6205 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6209 call = (???*0* ? ???*2* : (...) => ???*4*)((???*6* | ???*7*)) +- *0* ???*1*["clz32"] ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* updated with update expression ⚠️ This value might have side effects -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* ???*6*["value"] +- *1* FreeVar(Math) + ⚠️ unknown global + ⚠️ This value might have side effects +- *2* ???*3*["clz32"] ⚠️ unknown object + ⚠️ This value might have side effects +- *3* FreeVar(Math) + ⚠️ unknown global + ⚠️ This value might have side effects +- *4* ((0 === a) ? 32 : ???*5*) + ⚠️ nested operation +- *5* unsupported expression + ⚠️ This value might have side effects - *6* arguments[1] ⚠️ function calls are not analysed yet +- *7* unsupported assign operation + ⚠️ This value might have side effects -5649 -> 5655 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +0 -> 6211 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -5649 -> 5657 call = (...) => undefined( - (???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*), - (???*4* | ???*5* | null), - (???*7* | null["finishedLanes"]) +6211 -> 6212 free var = FreeVar(Error) + +6211 -> 6213 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(327) + +6211 -> 6214 call = ???*0*( + `Minified React error #${327}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["finishedWork"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* updated with update expression +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* ???*6*["value"] - ⚠️ unknown object -- *6* arguments[1] - ⚠️ function calls are not analysed yet -- *7* ???*8*["finishedLanes"] - ⚠️ unknown object -- *8* arguments[0] - ⚠️ function calls are not analysed yet +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${327}` + ⚠️ nested operation -5649 -> 5658 call = module["unstable_requestPaint"]() +0 -> 6215 call = (...) => (d | !(1))() -0 -> 5663 call = (...) => undefined( - (???*0* | null["finishedWork"]["stateNode"] | 0["stateNode"] | ???*2*), - (???*4* | ???*5* | null["onRecoverableError"]) -) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[2] +0 -> 6216 call = (...) => (0 | b | d)(???*0*, 0) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["stateNode"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* updated with update expression + +0 -> 6217 conditional = (0 === ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *4* arguments[3] - ⚠️ function calls are not analysed yet -- *5* ???*6*["onRecoverableError"] - ⚠️ unknown object -- *6* arguments[0] - ⚠️ function calls are not analysed yet -0 -> 5664 call = module["unstable_now"]() +6217 -> 6218 call = module["unstable_now"]() -0 -> 5665 call = (...) => undefined((???*0* | ???*1* | null), module["unstable_now"]()) +6217 -> 6219 call = (...) => undefined(???*0*, module["unstable_now"]()) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["value"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -0 -> 5666 conditional = (null !== ???*0*) -- *0* arguments[1] - ⚠️ function calls are not analysed yet +6217 -> 6220 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -5666 -> 5673 call = (???*0* | ???*1* | null["onRecoverableError"])( - (???*3* | null["finishedLanes"]["value"]), - { - "componentStack": (???*6* | null["finishedLanes"]["stack"]), - "digest": (???*9* | null["finishedLanes"]["digest"]) - } +6217 -> 6221 call = (...) => T( + ???*0*, + ( + | 0 + | ???*1* + | ???*3* + | undefined + | 1 + | 2 + | 4 + | 8 + | 16 + | 32 + | ???*4* + | 134217728 + | 268435456 + | 536870912 + | 1073741824 + | (???*5* ? (???*8* | ???*9*) : ???*10*) + ) ) -- *0* arguments[3] +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["onRecoverableError"] +- *1* ???*2*["entangledLanes"] ⚠️ unknown object - *2* arguments[0] ⚠️ function calls are not analysed yet -- *3* ???*4*["value"] - ⚠️ unknown object -- *4* ???*5*["finishedLanes"] - ⚠️ unknown object -- *5* arguments[0] +- *3* unsupported assign operation + ⚠️ This value might have side effects +- *4* unsupported expression + ⚠️ This value might have side effects +- *5* (0 !== (???*6* | ???*7*)) + ⚠️ nested operation +- *6* arguments[0] ⚠️ function calls are not analysed yet -- *6* ???*7*["stack"] - ⚠️ unknown object -- *7* ???*8*["finishedLanes"] - ⚠️ unknown object +- *7* unsupported expression + ⚠️ This value might have side effects - *8* arguments[0] ⚠️ function calls are not analysed yet -- *9* ???*10*["digest"] - ⚠️ unknown object -- *10* ???*11*["finishedLanes"] - ⚠️ unknown object -- *11* arguments[0] - ⚠️ function calls are not analysed yet +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* (???*11* ? 1073741824 : 0) + ⚠️ nested operation +- *11* unsupported expression + ⚠️ This value might have side effects -0 -> 5675 call = (...) => (d | !(1))() +6217 -> 6223 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5677 conditional = (0 !== ???*0*) +6223 -> 6224 call = (...) => ((0 !== a) ? a : (???*0* ? 1073741824 : 0))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -5677 -> 5678 conditional = ((???*0* | ???*1* | null) === (null | ???*3* | ???*4*)) +6223 -> 6225 call = (...) => a(???*0*, (???*1* ? (???*4* | ???*5*) : ???*6*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["value"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* arguments[0] +- *1* (0 !== (???*2* | ???*3*)) + ⚠️ nested operation +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["value"] - ⚠️ unknown object -- *5* arguments[1] +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* arguments[0] ⚠️ function calls are not analysed yet +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* (???*7* ? 1073741824 : 0) + ⚠️ nested operation +- *7* unsupported expression + ⚠️ This value might have side effects -0 -> 5679 call = (...) => null() +6217 -> 6226 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 5680 conditional = (null !== (null | ???*0* | ???*1*)) +6226 -> 6227 call = (...) => a(???*0*, 0) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["value"] + +6226 -> 6228 call = (...) => undefined( + ???*0*, + ( + | 0 + | ???*1* + | ???*3* + | undefined + | 1 + | 2 + | 4 + | 8 + | 16 + | 32 + | ???*4* + | 134217728 + | 268435456 + | 536870912 + | 1073741824 + | (???*5* ? (???*8* | ???*9*) : ???*10*) + ) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["entangledLanes"] ⚠️ unknown object -- *2* arguments[1] +- *2* arguments[0] ⚠️ function calls are not analysed yet - -5680 -> 5681 call = (...) => (???*0* ? (???*1* ? ((0 !== ???*2*) ? 16 : 536870912) : 4) : 1)((0 | ???*3* | null["finishedLanes"])) -- *0* unsupported expression +- *3* unsupported assign operation ⚠️ This value might have side effects -- *1* unsupported expression +- *4* unsupported expression ⚠️ This value might have side effects -- *2* unsupported expression +- *5* (0 !== (???*6* | ???*7*)) + ⚠️ nested operation +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* unsupported expression ⚠️ This value might have side effects -- *3* ???*4*["finishedLanes"] - ⚠️ unknown object -- *4* arguments[0] +- *8* arguments[0] ⚠️ function calls are not analysed yet +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* (???*11* ? 1073741824 : 0) + ⚠️ nested operation +- *11* unsupported expression + ⚠️ This value might have side effects -5680 -> 5684 conditional = (null === (null | ???*0* | ???*1*)) +6226 -> 6229 call = module["unstable_now"]() + +6226 -> 6230 call = (...) => undefined(???*0*, module["unstable_now"]()) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["value"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -5684 -> 5685 conditional = (0 !== ???*0*) -- *0* unsupported expression +6217 -> 6231 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5685 -> 5686 free var = FreeVar(Error) +6231 -> 6232 free var = FreeVar(Error) -5685 -> 5687 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(331) +6231 -> 6233 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(345) -5685 -> 5688 call = ???*0*( - `Minified React error #${331}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6231 -> 6234 call = ???*0*( + `Minified React error #${345}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${331}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${345}` ⚠️ nested operation -5684 -> 5692 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects - -5692 -> 5694 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5694 -> 5698 call = (...) => undefined(8, ???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6217 -> 6239 call = (...) => null(???*0*, ???*1*, null) +- *0* arguments[0] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -5694 -> 5700 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5700 -> 5704 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5700 -> 5705 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5694 -> 5708 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6217 -> 6240 call = module["unstable_now"]() -5708 -> 5710 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6217 -> 6241 call = (...) => undefined(???*0*, module["unstable_now"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5684 -> 5715 conditional = ???*0* -- *0* max number of linking steps reached +6217 -> 6242 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5715 -> 5718 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects +0 -> 6243 call = ???*0*(???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet -5718 -> 5721 call = (...) => undefined(9, ???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached +0 -> 6244 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5715 -> 5723 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6245 call = module["unstable_now"]() -5684 -> 5730 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6246 call = (...) => null() -5730 -> 5733 conditional = (0 !== ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects +0 -> 6248 call = (...) => (d | !(1))() -5733 -> 5735 call = (...) => undefined(9, ???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6251 call = ???*0*() +- *0* arguments[0] + ⚠️ function calls are not analysed yet -5733 -> 5737 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached +0 -> 6252 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *2* na - ⚠️ pattern without value -5730 -> 5739 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6254 call = (...) => null() -5684 -> 5743 call = (...) => null() +0 -> 6256 call = (...) => undefined({"current": 0}) -5684 -> 5745 conditional = (null | ???*0* | ("function" === ???*1*)) -- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* typeof((null["onPostCommitFiberRoot"] | ???*2*)) +0 -> 6261 call = (???*0* ? ???*3* : ???*4*)(???*5*) +- *0* ("function" === ???*1*) ⚠️ nested operation -- *2* ???*3*["onPostCommitFiberRoot"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *3* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global - ⚠️ This value might have side effects - -5745 -> 5747 member call = (null | ???*0*)["onPostCommitFiberRoot"]((null | ???*1*), ((???*3* ? ???*4* : 1) | null | ???*9* | ???*10*)) -- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) +- *1* typeof(???*2*) + ⚠️ nested operation +- *2* FreeVar(clearTimeout) ⚠️ unknown global ⚠️ This value might have side effects -- *1* ???*2*["inject"](vl) - ⚠️ unknown callee object - ⚠️ This value might have side effects -- *2* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) +- *3* FreeVar(clearTimeout) ⚠️ unknown global ⚠️ This value might have side effects -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* (???*5* ? ???*6* : 4) - ⚠️ nested operation -- *5* unsupported expression - ⚠️ This value might have side effects -- *6* (???*7* ? 16 : 536870912) - ⚠️ nested operation -- *7* (0 !== ???*8*) - ⚠️ nested operation -- *8* unsupported expression +- *4* unsupported expression ⚠️ This value might have side effects -- *9* arguments[0] - ⚠️ function calls are not analysed yet -- *10* ???*11*["value"] - ⚠️ unknown object -- *11* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 5749 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +- *5* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5750 call = (...) => c(???*0*, ???*1*, 1) +0 -> 6262 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5751 call = (...) => (null | Zg(a, c))(???*0*, ???*1*, 1) +6262 -> 6264 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5752 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* unsupported expression - ⚠️ This value might have side effects +6262 -> 6268 call = (...) => undefined() -0 -> 5753 call = (...) => undefined(???*0*, 1, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects +6262 -> 6269 call = (...) => undefined() -0 -> 5754 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects +6262 -> 6270 call = (...) => undefined({"current": false}) -0 -> 5756 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6262 -> 6271 call = (...) => undefined({"current": {}}) -5756 -> 5757 call = (...) => undefined(???*0*, ???*1*, ???*2*) +6262 -> 6272 call = (...) => undefined() + +6262 -> 6273 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* arguments[2] - ⚠️ function calls are not analysed yet -5756 -> 5759 conditional = ???*0* +6262 -> 6274 call = (...) => undefined() + +6262 -> 6275 call = (...) => undefined({"current": 0}) + +6262 -> 6276 call = (...) => undefined({"current": 0}) + +6262 -> 6279 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -5759 -> 5760 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +6262 -> 6280 call = (...) => undefined() + +0 -> 6283 call = (...) => c((???*0* | ???*2*), null) +- *0* ???*1*["current"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["current"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *3* unknown new expression ⚠️ This value might have side effects -- *2* arguments[2] + +0 -> 6284 conditional = (null !== (null | [???*0*])) +- *0* arguments[0] ⚠️ function calls are not analysed yet -5759 -> 5762 conditional = ???*0* +6284 -> 6291 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5762 -> 5768 member call = (???*0* | null)["has"](???*1*) -- *0* unknown new expression - ⚠️ This value might have side effects -- *1* max number of linking steps reached +0 -> 6296 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5762 -> 5769 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6297 call = (...) => undefined() -5769 -> 5770 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6299 conditional = (false | true) -5769 -> 5771 call = (...) => c(???*0*, ???*1*, 1) +0 -> 6309 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -5769 -> 5772 call = (...) => (null | Zg(a, c))(???*0*, ???*1*, 1) +6309 -> 6312 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -5769 -> 5773 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* unsupported expression +6312 -> 6314 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5769 -> 5774 call = (...) => undefined(???*0*, 1, ???*1*) +6309 -> 6323 call = (...) => (a | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -5769 -> 5775 call = (...) => undefined(???*0*, ???*1*) +6309 -> 6324 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5779 member call = ???*0*["delete"]((???*2* | (???*3* ? ???*5* : ???*6*))) -- *0* ???*1*["pingCache"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* (0 !== ???*4*) - ⚠️ nested operation -- *4* unsupported expression - ⚠️ This value might have side effects -- *5* module["unstable_now"]() - ⚠️ nested operation -- *6* (???*7* ? (???*11* | ???*12*) : ???*13*) - ⚠️ nested operation -- *7* (???*8* !== (???*9* | ???*10*)) - ⚠️ nested operation -- *8* unsupported expression - ⚠️ This value might have side effects -- *9* unsupported expression +6324 -> 6326 call = (...) => (???*0* | a)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +- *0* a + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *10* module["unstable_now"]() - ⚠️ nested operation -- *11* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *12* module["unstable_now"]() - ⚠️ nested operation -- *13* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects - -0 -> 5780 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *1* unsupported expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *2* unsupported expression +- *5* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5783 call = module["unstable_now"]() - -0 -> 5784 conditional = ( - | (4 === (3 | 0 | 1 | 2 | 4 | 6 | 5)) - | (3 === (3 | 0 | 1 | 2 | 4 | 6 | 5)) - | (???*0* === (0 | ???*1*)) - | ???*2* -) -- *0* unsupported expression +6324 -> 6328 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -5784 -> 5785 call = (...) => a(???*0*, 0) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5786 call = (...) => undefined(???*0*, (???*1* | (???*2* ? ???*4* : ???*5*))) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* (0 !== ???*3*) - ⚠️ nested operation -- *3* unsupported expression - ⚠️ This value might have side effects -- *4* module["unstable_now"]() - ⚠️ nested operation -- *5* (???*6* ? (???*10* | ???*11*) : ???*12*) - ⚠️ nested operation -- *6* (???*7* !== (???*8* | ???*9*)) - ⚠️ nested operation -- *7* unsupported expression - ⚠️ This value might have side effects -- *8* unsupported expression - ⚠️ This value might have side effects -- *9* module["unstable_now"]() - ⚠️ nested operation -- *10* unsupported expression - ⚠️ This value might have side effects -- *11* module["unstable_now"]() - ⚠️ nested operation -- *12* unsupported expression +6324 -> 6330 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5788 conditional = (0 === ???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects +6330 -> 6331 free var = FreeVar(Set) -0 -> 5789 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* unsupported expression +6330 -> 6333 member call = ???*0*["add"](???*1*) +- *0* unknown new expression ⚠️ This value might have side effects - -0 -> 5790 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)((???*0* | (???*1* ? ???*5* : null)), (???*8* | 1 | 4194304 | ???*9*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* (3 === ???*2*) - ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* ???*4*["alternate"] - ⚠️ unknown object -- *4* a - ⚠️ circular variable reference -- *5* ???*6*["stateNode"] - ⚠️ unknown object -- *6* ???*7*["alternate"] - ⚠️ unknown object -- *7* a - ⚠️ circular variable reference -- *8* arguments[1] - ⚠️ function calls are not analysed yet -- *9* unsupported assign operation +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5791 call = (...) => undefined( - (???*0* | (???*1* ? ???*5* : null)), - (???*8* | 1 | 4194304 | ???*9*), - (???*10* ? ???*12* : ???*13*) -) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* (3 === ???*2*) - ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* ???*4*["alternate"] - ⚠️ unknown object -- *4* a - ⚠️ circular variable reference -- *5* ???*6*["stateNode"] - ⚠️ unknown object -- *6* ???*7*["alternate"] - ⚠️ unknown object -- *7* a - ⚠️ circular variable reference -- *8* arguments[1] - ⚠️ function calls are not analysed yet -- *9* unsupported assign operation - ⚠️ This value might have side effects -- *10* (0 !== ???*11*) - ⚠️ nested operation -- *11* unsupported expression - ⚠️ This value might have side effects -- *12* module["unstable_now"]() - ⚠️ nested operation -- *13* (???*14* ? (???*18* | ???*19*) : ???*20*) - ⚠️ nested operation -- *14* (???*15* !== (???*16* | ???*17*)) - ⚠️ nested operation -- *15* unsupported expression - ⚠️ This value might have side effects -- *16* unsupported expression - ⚠️ This value might have side effects -- *17* module["unstable_now"]() - ⚠️ nested operation -- *18* unsupported expression +6330 -> 6336 member call = ???*0*["add"](???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *19* module["unstable_now"]() - ⚠️ nested operation -- *20* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5792 call = (...) => undefined((???*0* | (???*1* ? ???*5* : null)), (???*8* ? ???*10* : ???*11*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* (3 === ???*2*) - ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* ???*4*["alternate"] - ⚠️ unknown object -- *4* a - ⚠️ circular variable reference -- *5* ???*6*["stateNode"] - ⚠️ unknown object -- *6* ???*7*["alternate"] - ⚠️ unknown object -- *7* a - ⚠️ circular variable reference -- *8* (0 !== ???*9*) - ⚠️ nested operation -- *9* unsupported expression - ⚠️ This value might have side effects -- *10* module["unstable_now"]() - ⚠️ nested operation -- *11* (???*12* ? (???*16* | ???*17*) : ???*18*) - ⚠️ nested operation -- *12* (???*13* !== (???*14* | ???*15*)) - ⚠️ nested operation -- *13* unsupported expression +6324 -> 6337 conditional = (0 === ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *14* unsupported expression + +6337 -> 6338 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *15* module["unstable_now"]() - ⚠️ nested operation -- *16* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *17* module["unstable_now"]() - ⚠️ nested operation -- *18* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5795 call = (...) => undefined(???*0*, (0 | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["retryLane"] - ⚠️ unknown object -- *2* ???*3*["memoizedState"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet +6337 -> 6339 call = (...) => undefined() -0 -> 5801 free var = FreeVar(Error) +6324 -> 6340 free var = FreeVar(Error) -0 -> 5802 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(314) +6324 -> 6341 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(426) -0 -> 5803 call = ???*0*( - `Minified React error #${314}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6324 -> 6342 call = ???*0*( + `Minified React error #${426}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${314}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${426}` ⚠️ nested operation -0 -> 5805 member call = ???*0*["delete"](???*2*) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 5806 call = (...) => undefined(???*0*, (0 | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["retryLane"] - ⚠️ unknown object -- *2* ???*3*["memoizedState"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 5807 conditional = ???*0* -- *0* max number of linking steps reached +6309 -> 6344 conditional = (false | true | ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -5807 -> 5811 conditional = ???*0* +6344 -> 6345 call = (...) => (a | null)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -5811 -> 5814 conditional = (0 === ???*0*) -- *0* unsupported expression +6344 -> 6346 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5814 -> 5815 call = (...) => (???*0* | pj(a, b, c) | ((null !== a) ? a["sibling"] : null) | yj(a, b, c) | null | $i(a, b, c))(???*1*, ???*2*, ???*3*) -- *0* null +6346 -> 6349 call = (...) => (???*0* | a)(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +- *0* a ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -32965,723 +36591,1190 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ This value might have side effects - *3* max number of linking steps reached ⚠️ This value might have side effects - -5811 -> 5817 conditional = (0 !== ???*0*) -- *0* unsupported expression +- *4* max number of linking steps reached + ⚠️ This value might have side effects +- *5* max number of linking steps reached ⚠️ This value might have side effects -5807 -> 5820 call = (...) => undefined(???*0*, (0 | ???*1* | ???*2*), ???*4*) +6346 -> 6350 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* [][???*3*] - ⚠️ unknown array prototype methods or values -- *3* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *4* max number of linking steps reached + +6346 -> 6351 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5824 call = (...) => undefined(???*0*, ???*1*) +0 -> 6352 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5827 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)(???*0*, ({} | ???*1*)) +0 -> 6353 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unknown mutation - ⚠️ This value might have side effects -0 -> 5828 call = (...) => undefined(???*0*, ???*1*) +6353 -> 6355 member call = ???*0*["push"](???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5829 call = (...) => a(null, ???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +0 -> 6359 call = (...) => c(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects - *2* max number of linking steps reached ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 5830 call = (...) => a() -0 -> 5834 conditional = ???*0* +0 -> 6360 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - -5834 -> 5838 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) -- *0* unsupported expression - ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -5834 -> 5839 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects - -5839 -> 5840 call = (...) => !(0)(???*0*) -- *0* max number of linking steps reached +0 -> 6367 member call = (???*0* | null)["has"](???*1*) +- *0* unknown new expression ⚠️ This value might have side effects - -5834 -> 5844 conditional = ???*0* -- *0* max number of linking steps reached +- *1* max number of linking steps reached ⚠️ This value might have side effects -5834 -> 5846 call = (...) => undefined(???*0*) +0 -> 6368 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5834 -> 5850 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +6368 -> 6371 call = (...) => c(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects - *2* max number of linking steps reached ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -5834 -> 5851 call = (...) => ($i(a, b, f) | b["child"])(null, ???*0*, ???*1*, true, ???*2*, ???*3*) +6368 -> 6372 call = (...) => (undefined | FreeVar(undefined))(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -5834 -> 5853 call = (...) => undefined(???*0*) +0 -> 6374 call = (...) => (undefined | FreeVar(undefined))(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -5834 -> 5854 call = (...) => undefined(null, ???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +0 -> 6378 conditional = (null === module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"]["current"]) + +0 -> 6379 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* max number of linking steps reached + +0 -> 6380 call = (...) => undefined((null | ???*0* | ???*1* | ???*4*), (0 | ???*5*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["alternate"] + ⚠️ unknown object +- *2* ???*3*["current"] + ⚠️ unknown object +- *3* a + ⚠️ circular variable reference +- *4* unknown new expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *5* unsupported expression ⚠️ This value might have side effects -0 -> 5857 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +0 -> 6381 call = (...) => ((null === a) ? ai : a)() + +0 -> 6382 conditional = (((null | ???*0* | ???*1* | ???*4*) !== ???*5*) | ((0 | ???*6*) !== ???*7*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["alternate"] + ⚠️ unknown object +- *2* ???*3*["current"] + ⚠️ unknown object +- *3* a + ⚠️ circular variable reference +- *4* unknown new expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* unsupported expression ⚠️ This value might have side effects +- *7* arguments[1] + ⚠️ function calls are not analysed yet + +6382 -> 6383 call = (...) => a(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 6384 call = (...) => undefined() + +0 -> 6385 call = (...) => undefined(???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* e + ⚠️ pattern without value -0 -> 5861 call = ???*0*(???*1*) +0 -> 6386 call = (...) => undefined() + +0 -> 6388 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached + +6388 -> 6389 free var = FreeVar(Error) + +6388 -> 6390 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(261) + +6388 -> 6391 call = ???*0*( + `Minified React error #${261}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${261}` + ⚠️ nested operation -0 -> 5864 call = (...) => ((bj(a) ? 1 : 0) | 11 | 14 | 2)(???*0*) -- *0* max number of linking steps reached +0 -> 6392 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 5865 call = (...) => b(???*0*, ???*1*) +0 -> 6393 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached + +0 -> 6394 call = module["unstable_shouldYield"]() + +0 -> 6395 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5866 call = (...) => (???*0* | b["child"])(null, ???*1*, ???*2*, ???*3*, ???*4*) -- *0* $i(a, b, e) +0 -> 6397 call = ( + | ???*0* + | (...) => ( + | undefined + | ???*1* + | b + | null + | pj(a, b, c) + | b["child"] + | cj(a, b, b["type"], b["pendingProps"], c) + | yj(a, b, c) + | ej(a, b, c) + ) +)(???*2*, ???*4*, (???*5* | 0 | ???*6* | ???*7* | ???*8*)) +- *0* Wk + ⚠️ pattern without value +- *1* zj(a, b, c) ⚠️ sequence with side effects ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *2* ???*3*["alternate"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* unsupported assign operation ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *6* unknown mutation ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *7* arguments[1] + ⚠️ function calls are not analysed yet +- *8* updated with update expression ⚠️ This value might have side effects -- *4* max number of linking steps reached + +0 -> 6400 conditional = (null === ???*0*) +- *0* ( + | ???*1* + | (...) => ( + | undefined + | ???*2* + | b + | null + | pj(a, b, c) + | b["child"] + | cj(a, b, b["type"], b["pendingProps"], c) + | yj(a, b, c) + | ej(a, b, c) + ) + )(a["alternate"], a, gj) + ⚠️ non-function callee +- *1* Wk + ⚠️ pattern without value +- *2* zj(a, b, c) + ⚠️ sequence with side effects ⚠️ This value might have side effects -0 -> 5867 call = (...) => kj(a, b, c, d, f, e)(null, ???*0*, ???*1*, ???*2*, ???*3*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached +6400 -> 6401 call = (...) => (undefined | FreeVar(undefined))(???*0*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 6406 conditional = (0 === ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -0 -> 5868 call = (...) => (???*0* | b["child"])(null, ???*1*, ???*2*, ???*3*, ???*4*) -- *0* $i(a, b, e) - ⚠️ sequence with side effects +6406 -> 6407 call = (...) => (undefined | null | (???*0* ? b : null) | ???*1* | b["child"])(???*2*, (???*3* | ???*4*), (???*6* | 0 | ???*7* | ???*8* | ???*9*)) +- *0* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *1* b + ⚠️ sequence with side effects ⚠️ This value might have side effects - *2* max number of linking steps reached ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["return"] + ⚠️ unknown object +- *5* b + ⚠️ circular variable reference +- *6* unsupported assign operation ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *7* unknown mutation ⚠️ This value might have side effects - -0 -> 5870 call = (...) => b(???*0*, ???*1*) -- *0* max number of linking steps reached +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* updated with update expression ⚠️ This value might have side effects -- *1* max number of linking steps reached + +6406 -> 6408 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 5871 call = (...) => (???*0* | ???*1* | $i(a, b, e))(null, ???*2*, ???*3*, ???*4*, ???*5*) -- *0* cj(a, b, f, d, e) +6406 -> 6409 call = (...) => (undefined | ???*0* | null | (???*3* ? ???*4* : null))(???*5*, (???*6* | ???*7*)) +- *0* (???*1* ? ???*2* : null) ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *2* b + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *3* unsupported expression ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *4* b + ⚠️ sequence with side effects ⚠️ This value might have side effects - *5* max number of linking steps reached ⚠️ This value might have side effects +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* ???*8*["return"] + ⚠️ unknown object +- *8* b + ⚠️ circular variable reference -0 -> 5872 free var = FreeVar(Error) - -0 -> 5873 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(306, ???*0*, "") +6406 -> 6410 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5874 call = ???*0*(???*1*) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* max number of linking steps reached +6410 -> 6412 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 5878 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +6410 -> 6413 conditional = (null !== (???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference -5878 -> 5879 call = (...) => b(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached +6413 -> 6414 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 5880 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) -- *0* $i(a, b, e) - ⚠️ sequence with side effects +0 -> 6419 conditional = (null !== (???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["return"] + ⚠️ unknown object +- *2* b + ⚠️ circular variable reference + +6419 -> 6420 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* max number of linking steps reached + +0 -> 6423 call = (...) => null( + ???*0*, + ???*1*, + ???*2*, + ( + | 0 + | 1 + | ???*3* + | 4 + | ((???*4* | ???*6*) ? ???*7* : 4) + | (???*8* ? 16 : (???*9* | null | ???*16* | ???*17*)) + | ???*19* + ) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* arguments[2] + ⚠️ function calls are not analysed yet +- *3* C + ⚠️ circular variable reference +- *4* (0 !== ???*5*) + ⚠️ nested operation +- *5* C + ⚠️ circular variable reference +- *6* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *7* C + ⚠️ circular variable reference +- *8* unsupported expression ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *9* (???*10* ? ???*11* : 1) + ⚠️ nested operation +- *10* unsupported expression ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *11* (???*12* ? ???*13* : 4) + ⚠️ nested operation +- *12* unsupported expression ⚠️ This value might have side effects -- *5* max number of linking steps reached +- *13* (???*14* ? 16 : 536870912) + ⚠️ nested operation +- *14* (0 !== ???*15*) + ⚠️ nested operation +- *15* unsupported expression ⚠️ This value might have side effects +- *16* arguments[0] + ⚠️ function calls are not analysed yet +- *17* ???*18*["value"] + ⚠️ unknown object +- *18* arguments[1] + ⚠️ function calls are not analysed yet +- *19* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5884 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 6425 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -5884 -> 5885 call = (...) => b(???*0*, ???*1*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6426 call = (...) => (d | !(1))() -0 -> 5886 call = (...) => kj(a, b, c, d, f, e)(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached +0 -> 6427 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *3* max number of linking steps reached + +6427 -> 6428 free var = FreeVar(Error) + +6427 -> 6429 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(327) + +6427 -> 6430 call = ???*0*( + `Minified React error #${327}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${327}` + ⚠️ nested operation + +0 -> 6433 conditional = (null === (???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["finishedWork"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* updated with update expression ⚠️ This value might have side effects -0 -> 5887 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached +6433 -> 6434 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 5888 conditional = ???*0* -- *0* max number of linking steps reached +6433 -> 6438 conditional = ((???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*) === (???*4* | null["current"])) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["finishedWork"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* updated with update expression ⚠️ This value might have side effects +- *4* ???*5*["current"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet -5888 -> 5889 free var = FreeVar(Error) +6438 -> 6439 free var = FreeVar(Error) -5888 -> 5890 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(387) +6438 -> 6440 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(177) -5888 -> 5891 call = ???*0*( - `Minified React error #${387}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6438 -> 6441 call = ???*0*( + `Minified React error #${177}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${387}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${177}` ⚠️ nested operation -0 -> 5895 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +6433 -> 6446 call = (...) => undefined( + (???*0* | ???*1* | null), + ( + | ???*3* + | (0 !== ???*4*) + | module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentBatchConfig"]["transition"] + | ???*5* + | null["pendingLanes"] + ) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["value"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *4* unsupported expression ⚠️ This value might have side effects +- *5* ???*6*["pendingLanes"] + ⚠️ unknown object +- *6* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5896 call = (...) => undefined(???*0*, ???*1*, null, ???*2*) -- *0* max number of linking steps reached +6433 -> 6449 call = (...) => ac(a, b)(module["unstable_NormalPriority"], (...) => null) + +6449 -> 6450 call = (...) => (d | !(1))() + +6449 -> 6451 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* max number of linking steps reached + +6433 -> 6454 conditional = ( + | (0 !== ???*0*) + | ???*1* + | module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentBatchConfig"]["transition"] + | ???*2* + | null["pendingLanes"] +) +- *0* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *1* unsupported expression ⚠️ This value might have side effects +- *2* ???*3*["pendingLanes"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 5900 conditional = ???*0* -- *0* max number of linking steps reached +6454 -> 6458 call = (...) => n( + (???*0* | ???*1* | null), + (???*3* | ???*4* | null["finishedWork"] | 0 | ???*6*) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["value"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* arguments[2] + ⚠️ function calls are not analysed yet +- *4* ???*5*["finishedWork"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* updated with update expression ⚠️ This value might have side effects -5900 -> 5908 free var = FreeVar(Error) +6454 -> 6459 call = (...) => undefined( + (???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*), + (???*4* | ???*5* | null) +) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["finishedWork"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* updated with update expression + ⚠️ This value might have side effects +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* ???*6*["value"] + ⚠️ unknown object +- *6* arguments[1] + ⚠️ function calls are not analysed yet -5900 -> 5909 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(423) +6454 -> 6460 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5900 -> 5910 call = ???*0*( - `Minified React error #${423}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6454 -> 6462 call = (...) => undefined( + (???*0* | ???*1* | null["finishedWork"] | 0 | ???*3*), + (???*4* | ???*5* | null), + (???*7* | null["finishedLanes"]) ) -- *0* FreeVar(Error) - ⚠️ unknown global +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* ???*2*["finishedWork"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* updated with update expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${423}` - ⚠️ nested operation +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* ???*6*["value"] + ⚠️ unknown object +- *6* arguments[1] + ⚠️ function calls are not analysed yet +- *7* ???*8*["finishedLanes"] + ⚠️ unknown object +- *8* arguments[0] + ⚠️ function calls are not analysed yet -5900 -> 5911 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*2*) -- *0* ???*1*(p(423)) - ⚠️ unknown callee - ⚠️ This value might have side effects -- *1* FreeVar(Error) - ⚠️ unknown global +6454 -> 6463 call = module["unstable_requestPaint"]() + +6433 -> 6468 call = (...) => undefined( + (???*0* | null["finishedWork"]["stateNode"] | 0["stateNode"] | ???*2*), + (???*4* | ???*5* | null["onRecoverableError"]) +) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* ???*3*["stateNode"] + ⚠️ unknown object ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *3* updated with update expression ⚠️ This value might have side effects +- *4* arguments[3] + ⚠️ function calls are not analysed yet +- *5* ???*6*["onRecoverableError"] + ⚠️ unknown object +- *6* arguments[0] + ⚠️ function calls are not analysed yet -5900 -> 5912 call = (...) => b["child"](???*0*, ???*1*, ???*2*, ???*3*, ???*4*) -- *0* max number of linking steps reached +6433 -> 6469 call = module["unstable_now"]() + +6433 -> 6470 call = (...) => undefined((???*0* | ???*1* | null), module["unstable_now"]()) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["value"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +6433 -> 6471 conditional = (null !== ???*0*) +- *0* arguments[1] + ⚠️ function calls are not analysed yet + +6471 -> 6478 call = (???*0* | ???*1* | null["onRecoverableError"])( + (???*3* | null["finishedLanes"]["value"]), + { + "componentStack": (???*6* | null["finishedLanes"]["stack"]), + "digest": (???*9* | null["finishedLanes"]["digest"]) + } +) +- *0* arguments[3] + ⚠️ function calls are not analysed yet +- *1* ???*2*["onRecoverableError"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["value"] + ⚠️ unknown object +- *4* ???*5*["finishedLanes"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["stack"] + ⚠️ unknown object +- *7* ???*8*["finishedLanes"] + ⚠️ unknown object +- *8* arguments[0] + ⚠️ function calls are not analysed yet +- *9* ???*10*["digest"] + ⚠️ unknown object +- *10* ???*11*["finishedLanes"] + ⚠️ unknown object +- *11* arguments[0] + ⚠️ function calls are not analysed yet + +6433 -> 6480 call = (...) => (d | !(1))() + +6433 -> 6482 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached + +6482 -> 6483 conditional = ((???*0* | ???*1* | null) === (null | ???*3* | ???*4*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["value"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["value"] + ⚠️ unknown object +- *5* arguments[1] + ⚠️ function calls are not analysed yet + +6433 -> 6484 call = (...) => null() + +6433 -> 6485 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *2* max number of linking steps reached + +0 -> 6486 conditional = (null !== (null | ???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["value"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +6486 -> 6487 call = (...) => (???*0* ? (???*1* ? ((0 !== ???*2*) ? 16 : 536870912) : 4) : 1)((0 | ???*3* | null["finishedLanes"])) +- *0* unsupported expression ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *1* unsupported expression ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *2* unsupported expression ⚠️ This value might have side effects +- *3* ???*4*["finishedLanes"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet -5900 -> 5913 conditional = ???*0* -- *0* max number of linking steps reached +6486 -> 6490 conditional = (null === (null | ???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["value"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +6490 -> 6491 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -5913 -> 5914 free var = FreeVar(Error) +6491 -> 6492 free var = FreeVar(Error) -5913 -> 5915 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(424) +6491 -> 6493 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(331) -5913 -> 5916 call = ???*0*( - `Minified React error #${424}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6491 -> 6494 call = ???*0*( + `Minified React error #${331}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${424}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${331}` ⚠️ nested operation -5913 -> 5917 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*2*) -- *0* ???*1*(p(424)) - ⚠️ unknown callee - ⚠️ This value might have side effects -- *1* FreeVar(Error) - ⚠️ unknown global +6490 -> 6498 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached + +6498 -> 6500 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5913 -> 5918 call = (...) => b["child"](???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +6500 -> 6504 call = (...) => undefined(8, ???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects -5913 -> 5922 call = (...) => (null | a)(???*0*) +6500 -> 6506 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5913 -> 5923 call = (...) => ( - | g(a) - | ???*0* - | n(a, d, f, h) - | t(a, d, f, h) - | (((("string" === typeof(f)) && ("" !== f)) || ("number" === typeof(f))) ? ???*1* : c(a, d)) -)(???*2*, null, ???*3*, ???*4*) -- *0* J(a, d, l(f["_payload"]), h) - ⚠️ sequence with side effects - ⚠️ This value might have side effects -- *1* g(a) - ⚠️ sequence with side effects - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -- *4* max number of linking steps reached +6506 -> 6510 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -5900 -> 5928 call = (...) => undefined() +6506 -> 6511 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -5900 -> 5929 conditional = ???*0* +6500 -> 6514 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5929 -> 5930 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +6514 -> 6516 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached + +6490 -> 6521 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached + +6521 -> 6524 conditional = (0 !== ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -5900 -> 5931 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +6524 -> 6527 call = (...) => undefined(9, ???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5933 call = (...) => undefined(???*0*) +6521 -> 6529 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5934 call = (...) => undefined(???*0*) +6490 -> 6536 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5937 conditional = ???*0* +6536 -> 6539 conditional = (0 !== ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects + +6539 -> 6541 call = (...) => undefined(9, ???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5940 call = (...) => ( - || ("textarea" === a) - || ("noscript" === a) - || ("string" === typeof(b["children"])) - || ("number" === typeof(b["children"])) - || ( - && ("object" === typeof(b["dangerouslySetInnerHTML"])) - && (null !== b["dangerouslySetInnerHTML"]) - && (null != b["dangerouslySetInnerHTML"]["__html"]) - ) -)(???*0*, ???*1*) +6539 -> 6543 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects +- *2* na + ⚠️ pattern without value -0 -> 5941 conditional = ???*0* +6536 -> 6545 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5941 -> 5942 call = (...) => ( - || ("textarea" === a) - || ("noscript" === a) - || ("string" === typeof(b["children"])) - || ("number" === typeof(b["children"])) - || ( - && ("object" === typeof(b["dangerouslySetInnerHTML"])) - && (null !== b["dangerouslySetInnerHTML"]) - && (null != b["dangerouslySetInnerHTML"]["__html"]) - ) -)(???*0*, ???*1*) -- *0* max number of linking steps reached +6490 -> 6549 call = (...) => null() + +6490 -> 6551 conditional = (null | ???*0* | ("function" === ???*1*)) +- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* typeof((null["onPostCommitFiberRoot"] | ???*2*)) + ⚠️ nested operation +- *2* ???*3*["onPostCommitFiberRoot"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *3* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global + ⚠️ This value might have side effects + +6551 -> 6553 member call = (null | ???*0*)["onPostCommitFiberRoot"]((null | ???*1*), ((???*3* ? ???*4* : 1) | null | ???*9* | ???*10*)) +- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* ???*2*["inject"](vl) + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *2* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* (???*5* ? ???*6* : 4) + ⚠️ nested operation +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* (???*7* ? 16 : 536870912) + ⚠️ nested operation +- *7* (0 !== ???*8*) + ⚠️ nested operation +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* arguments[0] + ⚠️ function calls are not analysed yet +- *10* ???*11*["value"] + ⚠️ unknown object +- *11* arguments[1] + ⚠️ function calls are not analysed yet + +6486 -> 6554 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6556 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects + +0 -> 6557 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5944 call = (...) => undefined(???*0*, ???*1*) +0 -> 6558 call = (...) => c(???*0*, ???*1*, 1) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5945 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +0 -> 6559 call = (...) => (null | Zg(a, c))(???*0*, ???*1*, 1) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects - -0 -> 5947 call = (...) => undefined(???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5948 call = (...) => (???*0* | (f ? ???*1* : rj(b, g)) | sj(a, b, g, d, h, e, c) | d)(???*2*, ???*3*, ???*4*) -- *0* null - ⚠️ sequence with side effects +0 -> 6560 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression ⚠️ This value might have side effects -- *1* a - ⚠️ sequence with side effects +- *1* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *2* unsupported expression ⚠️ This value might have side effects -- *3* max number of linking steps reached + +0 -> 6561 call = (...) => undefined(???*0*, 1, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5951 call = (...) => undefined(???*0*, ???*1*) +0 -> 6562 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5953 conditional = ???*0* +0 -> 6564 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5953 -> 5955 call = (...) => ( - | g(a) - | ???*0* - | n(a, d, f, h) - | t(a, d, f, h) - | (((("string" === typeof(f)) && ("" !== f)) || ("number" === typeof(f))) ? ???*1* : c(a, d)) -)(???*2*, null, ???*3*, ???*4*) -- *0* J(a, d, l(f["_payload"]), h) - ⚠️ sequence with side effects - ⚠️ This value might have side effects -- *1* g(a) - ⚠️ sequence with side effects - ⚠️ This value might have side effects -- *2* max number of linking steps reached +6564 -> 6565 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *2* arguments[2] + ⚠️ function calls are not analysed yet + +6564 -> 6567 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -5953 -> 5956 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +6567 -> 6568 call = (...) => undefined(???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects +- *2* arguments[2] + ⚠️ function calls are not analysed yet -0 -> 5961 conditional = ???*0* +6567 -> 6570 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -5961 -> 5962 call = (...) => b(???*0*, ???*1*) -- *0* max number of linking steps reached +6570 -> 6576 member call = (???*0* | null)["has"](???*1*) +- *0* unknown new expression ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 5963 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) -- *0* $i(a, b, e) - ⚠️ sequence with side effects +6570 -> 6577 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects + +6577 -> 6578 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*1*) +- *0* arguments[2] + ⚠️ function calls are not analysed yet - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects -- *5* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5965 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +6577 -> 6579 call = (...) => c(???*0*, ???*1*, 1) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5969 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +6577 -> 6580 call = (...) => (null | Zg(a, c))(???*0*, ???*1*, 1) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached + +6577 -> 6581 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression ⚠️ This value might have side effects -- *3* max number of linking steps reached +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* unsupported expression ⚠️ This value might have side effects -0 -> 5973 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +6577 -> 6582 call = (...) => undefined(???*0*, 1, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -- *3* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 5981 call = (...) => undefined({"current": null}, ???*0*) +6577 -> 6583 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - -0 -> 5983 conditional = ???*0* -- *0* max number of linking steps reached +- *1* max number of linking steps reached ⚠️ This value might have side effects -5983 -> 5985 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) -- *0* ("function" === ???*1*) - ⚠️ nested operation -- *1* typeof(???*2*) - ⚠️ nested operation -- *2* ???*3*["is"] +0 -> 6587 member call = ???*0*["delete"]((???*2* | (???*3* ? ???*5* : ???*6*))) +- *0* ???*1*["pingCache"] ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* (0 !== ???*4*) + ⚠️ nested operation +- *4* unsupported expression ⚠️ This value might have side effects -- *3* FreeVar(Object) - ⚠️ unknown global +- *5* module["unstable_now"]() + ⚠️ nested operation +- *6* (???*7* ? (???*11* | ???*12*) : ???*13*) + ⚠️ nested operation +- *7* (???*8* !== (???*9* | ???*10*)) + ⚠️ nested operation +- *8* unsupported expression ⚠️ This value might have side effects -- *4* ???*5*["is"] - ⚠️ unknown object +- *9* unsupported expression ⚠️ This value might have side effects -- *5* FreeVar(Object) - ⚠️ unknown global +- *10* module["unstable_now"]() + ⚠️ nested operation +- *11* unsupported expression ⚠️ This value might have side effects -- *6* (((a === b) && ((0 !== a) || (???*7* === ???*8*))) || ((a !== a) && (b !== b))) +- *12* module["unstable_now"]() ⚠️ nested operation -- *7* unsupported expression +- *13* unsupported expression ⚠️ This value might have side effects -- *8* unsupported expression + +0 -> 6588 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression ⚠️ This value might have side effects -- *9* max number of linking steps reached +- *1* unsupported expression ⚠️ This value might have side effects -- *10* max number of linking steps reached +- *2* unsupported expression ⚠️ This value might have side effects -5983 -> 5986 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 6591 call = module["unstable_now"]() -5986 -> 5990 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 6592 conditional = ( + | (4 === (3 | 0 | 1 | 2 | 4 | 6 | 5)) + | (3 === (3 | 0 | 1 | 2 | 4 | 6 | 5)) + | (???*0* === (0 | ???*1*)) + | ???*2* +) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* unsupported expression ⚠️ This value might have side effects -5990 -> 5991 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +6592 -> 6593 call = (...) => a(???*0*, 0) +- *0* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 6594 call = (...) => undefined(???*0*, (???*1* | (???*2* ? ???*4* : ???*5*))) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* (0 !== ???*3*) + ⚠️ nested operation +- *3* unsupported expression ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *4* module["unstable_now"]() + ⚠️ nested operation +- *5* (???*6* ? (???*10* | ???*11*) : ???*12*) + ⚠️ nested operation +- *6* (???*7* !== (???*8* | ???*9*)) + ⚠️ nested operation +- *7* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *8* unsupported expression ⚠️ This value might have side effects - -5986 -> 5995 conditional = ???*0* -- *0* max number of linking steps reached +- *9* module["unstable_now"]() + ⚠️ nested operation +- *10* unsupported expression ⚠️ This value might have side effects - -5995 -> 5999 conditional = ???*0* -- *0* max number of linking steps reached +- *11* module["unstable_now"]() + ⚠️ nested operation +- *12* unsupported expression ⚠️ This value might have side effects -5999 -> 6001 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 6596 conditional = (0 === ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -6001 -> 6002 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}(???*0*, ???*1*) +0 -> 6597 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression ⚠️ This value might have side effects - -6001 -> 6005 conditional = ???*0* -- *0* max number of linking steps reached +- *2* unsupported expression ⚠️ This value might have side effects -6005 -> 6008 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 6598 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)((???*0* | (???*1* ? ???*5* : null)), (???*8* | 1 | 4194304 | ???*9*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* (3 === ???*2*) + ⚠️ nested operation +- *2* ???*3*["tag"] + ⚠️ unknown object +- *3* ???*4*["alternate"] + ⚠️ unknown object +- *4* a + ⚠️ circular variable reference +- *5* ???*6*["stateNode"] + ⚠️ unknown object +- *6* ???*7*["alternate"] + ⚠️ unknown object +- *7* a + ⚠️ circular variable reference +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* unsupported assign operation ⚠️ This value might have side effects -5999 -> 6018 call = (...) => undefined(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +0 -> 6599 call = (...) => undefined( + (???*0* | (???*1* ? ???*5* : null)), + (???*8* | 1 | 4194304 | ???*9*), + (???*10* ? ???*12* : ???*13*) +) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* (3 === ???*2*) + ⚠️ nested operation +- *2* ???*3*["tag"] + ⚠️ unknown object +- *3* ???*4*["alternate"] + ⚠️ unknown object +- *4* a + ⚠️ circular variable reference +- *5* ???*6*["stateNode"] + ⚠️ unknown object +- *6* ???*7*["alternate"] + ⚠️ unknown object +- *7* a + ⚠️ circular variable reference +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* unsupported assign operation ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *10* (0 !== ???*11*) + ⚠️ nested operation +- *11* unsupported expression ⚠️ This value might have side effects -- *2* max number of linking steps reached +- *12* module["unstable_now"]() + ⚠️ nested operation +- *13* (???*14* ? (???*18* | ???*19*) : ???*20*) + ⚠️ nested operation +- *14* (???*15* !== (???*16* | ???*17*)) + ⚠️ nested operation +- *15* unsupported expression ⚠️ This value might have side effects - -5995 -> 6022 conditional = ???*0* -- *0* max number of linking steps reached +- *16* unsupported expression ⚠️ This value might have side effects - -6022 -> 6025 conditional = ???*0* -- *0* max number of linking steps reached +- *17* module["unstable_now"]() + ⚠️ nested operation +- *18* unsupported expression ⚠️ This value might have side effects - -6022 -> 6028 conditional = ???*0* -- *0* max number of linking steps reached +- *19* module["unstable_now"]() + ⚠️ nested operation +- *20* unsupported expression ⚠️ This value might have side effects -6028 -> 6030 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 6600 call = (...) => undefined((???*0* | (???*1* ? ???*5* : null)), (???*8* ? ???*10* : ???*11*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* (3 === ???*2*) + ⚠️ nested operation +- *2* ???*3*["tag"] + ⚠️ unknown object +- *3* ???*4*["alternate"] + ⚠️ unknown object +- *4* a + ⚠️ circular variable reference +- *5* ???*6*["stateNode"] + ⚠️ unknown object +- *6* ???*7*["alternate"] + ⚠️ unknown object +- *7* a + ⚠️ circular variable reference +- *8* (0 !== ???*9*) + ⚠️ nested operation +- *9* unsupported expression + ⚠️ This value might have side effects +- *10* module["unstable_now"]() + ⚠️ nested operation +- *11* (???*12* ? (???*16* | ???*17*) : ???*18*) + ⚠️ nested operation +- *12* (???*13* !== (???*14* | ???*15*)) + ⚠️ nested operation +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* unsupported expression ⚠️ This value might have side effects +- *15* module["unstable_now"]() + ⚠️ nested operation +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* module["unstable_now"]() + ⚠️ nested operation +- *18* unsupported expression + ⚠️ This value might have side effects + +0 -> 6603 call = (...) => undefined(???*0*, (0 | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["retryLane"] + ⚠️ unknown object +- *2* ???*3*["memoizedState"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet -6030 -> 6031 free var = FreeVar(Error) +0 -> 6609 free var = FreeVar(Error) -6030 -> 6032 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(341) +0 -> 6610 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(314) -6030 -> 6033 call = ???*0*( - `Minified React error #${341}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +0 -> 6611 call = ???*0*( + `Minified React error #${314}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${341}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${314}` ⚠️ nested operation -6028 -> 6037 call = (...) => undefined(???*0*, ???*1*, ???*2*) +0 -> 6613 member call = ???*0*["delete"](???*2*) +- *0* ???*1*["stateNode"] + ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 6614 call = (...) => undefined(???*0*, (0 | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["retryLane"] + ⚠️ unknown object +- *2* ???*3*["memoizedState"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 6615 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -5986 -> 6040 conditional = ???*0* +6615 -> 6619 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -6040 -> 6043 conditional = ???*0* -- *0* max number of linking steps reached +6619 -> 6622 conditional = (0 === ???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -0 -> 6048 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) -- *0* max number of linking steps reached +6622 -> 6623 call = (...) => (???*0* | pj(a, b, c) | ((null !== a) ? a["sibling"] : null) | yj(a, b, c) | null | $i(a, b, c))(???*1*, ???*2*, ???*3*) +- *0* null + ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects @@ -33690,23 +37783,45 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6053 call = (...) => undefined(???*0*, ???*1*) +6622 -> 6624 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +6622 -> 6626 conditional = (0 !== ???*0*) +- *0* unsupported expression + ⚠️ This value might have side effects + +6615 -> 6629 call = (...) => undefined(???*0*, (0 | ???*1* | ???*2*), ???*4*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* [][???*3*] + ⚠️ unknown array prototype methods or values +- *3* unsupported expression + ⚠️ This value might have side effects +- *4* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6633 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6054 call = (...) => b(???*0*) +0 -> 6636 call = (...) => (Vf | d["__reactInternalMemoizedMaskedChildContext"] | e)(???*0*, ({} | ???*1*)) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* unknown mutation + ⚠️ This value might have side effects -0 -> 6055 call = ???*0*(???*1*) +0 -> 6637 call = (...) => undefined(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6057 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +0 -> 6638 call = (...) => a(null, ???*0*, ???*1*, ???*2*, ???*3*, ???*4*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -33715,39 +37830,49 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ This value might have side effects - *3* max number of linking steps reached ⚠️ This value might have side effects +- *4* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6061 call = (...) => b(???*0*, ???*1*) +0 -> 6639 call = (...) => a() + +0 -> 6643 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects + +6643 -> 6647 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +- *0* unsupported expression + ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6063 call = (...) => b(???*0*, ???*1*) +6643 -> 6648 conditional = ???*0* - *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 6064 call = (...) => (???*0* | ???*1* | $i(a, b, e))(???*2*, ???*3*, ???*4*, ???*5*, ???*6*) -- *0* cj(a, b, f, d, e) - ⚠️ sequence with side effects +6648 -> 6649 call = (...) => !(0)(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unsupported expression + +6643 -> 6653 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached + +6643 -> 6655 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* max number of linking steps reached + +6643 -> 6659 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *4* max number of linking steps reached +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *5* max number of linking steps reached +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *6* max number of linking steps reached +- *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6067 call = (...) => (???*0* | dj(a, b, c, d, e))(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) -- *0* $i(a, b, e) - ⚠️ sequence with side effects +6643 -> 6660 call = (...) => ($i(a, b, f) | b["child"])(null, ???*0*, ???*1*, true, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects @@ -33755,56 +37880,59 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ This value might have side effects - *3* max number of linking steps reached ⚠️ This value might have side effects -- *4* max number of linking steps reached - ⚠️ This value might have side effects -- *5* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 6071 conditional = ???*0* +6643 -> 6662 call = (...) => undefined(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -6071 -> 6072 call = (...) => b(???*0*, ???*1*) +6643 -> 6663 call = (...) => undefined(null, ???*0*, ???*1*, ???*2*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects - -0 -> 6073 call = (...) => undefined(???*0*, ???*1*) -- *0* max number of linking steps reached +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *1* max number of linking steps reached + +0 -> 6665 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 6075 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) -- *0* unsupported expression +0 -> 6667 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6076 conditional = ???*0* +0 -> 6671 call = ???*0*(???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects -6076 -> 6077 call = (...) => !(0)(???*0*) +0 -> 6674 call = (...) => ((bj(a) ? 1 : 0) | 11 | 14 | 2)(???*0*) - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6078 call = (...) => undefined(???*0*, ???*1*) +0 -> 6675 call = (...) => b(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6079 call = (...) => b(???*0*, ???*1*, ???*2*) -- *0* max number of linking steps reached +0 -> 6676 call = (...) => (???*0* | b["child"])(null, ???*1*, ???*2*, ???*3*, ???*4*) +- *0* $i(a, b, e) + ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects - *2* max number of linking steps reached ⚠️ This value might have side effects +- *3* max number of linking steps reached + ⚠️ This value might have side effects +- *4* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6080 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +0 -> 6677 call = (...) => kj(a, b, c, d, f, e)(null, ???*0*, ???*1*, ???*2*, ???*3*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached @@ -33814,8 +37942,9 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6081 call = (...) => ($i(a, b, f) | b["child"])(null, ???*0*, ???*1*, true, ???*2*, ???*3*) -- *0* max number of linking steps reached +0 -> 6678 call = (...) => (???*0* | b["child"])(null, ???*1*, ???*2*, ???*3*, ???*4*) +- *0* $i(a, b, e) + ⚠️ sequence with side effects ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects @@ -33823,2575 +37952,2130 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` ⚠️ This value might have side effects - *3* max number of linking steps reached ⚠️ This value might have side effects +- *4* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6082 call = (...) => b["child"](???*0*, ???*1*, ???*2*) +0 -> 6680 call = (...) => b(???*0*, ???*1*) - *0* max number of linking steps reached ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* max number of linking steps reached - ⚠️ This value might have side effects -0 -> 6083 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*) -- *0* null +0 -> 6681 call = (...) => (???*0* | ???*1* | $i(a, b, e))(null, ???*2*, ???*3*, ???*4*, ???*5*) +- *0* cj(a, b, f, d, e) ⚠️ sequence with side effects ⚠️ This value might have side effects -- *1* max number of linking steps reached +- *1* unsupported expression ⚠️ This value might have side effects - *2* max number of linking steps reached ⚠️ This value might have side effects - *3* max number of linking steps reached ⚠️ This value might have side effects +- *4* max number of linking steps reached + ⚠️ This value might have side effects +- *5* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6084 free var = FreeVar(Error) +0 -> 6682 free var = FreeVar(Error) -0 -> 6086 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(156, ???*0*) +0 -> 6683 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(306, ???*0*, "") - *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6087 call = ???*0*(???*1*) +0 -> 6684 call = ???*0*(???*1*) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects - *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6088 call = module["unstable_scheduleCallback"](???*0*, ???*1*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 6113 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | ???*2*)) - ⚠️ nested operation -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["$$typeof"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference - -6113 -> 6114 call = (...) => !((!(a) || !(a["isReactComponent"])))((???*0* | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["$$typeof"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference - -6113 -> 6115 conditional = !(???*0*) -- *0* !((???*1* | ???*2*)) - ⚠️ nested operation -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["$$typeof"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference - -0 -> 6116 conditional = ((???*0* !== (???*1* | ???*2*)) | (null !== (???*4* | ???*5*))) -- *0* unsupported expression +0 -> 6685 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* ???*3*["$$typeof"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* ???*6*["$$typeof"] - ⚠️ unknown object -- *6* a - ⚠️ circular variable reference -0 -> 6119 conditional = (null === (???*0* | ???*2*)) -- *0* ???*1*["alternate"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +0 -> 6689 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -6119 -> 6123 call = (...) => ???*0*(???*1*, (???*3* | ???*4*), ???*6*, ???*8*) -- *0* unknown new expression +6689 -> 6690 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* ???*2*["tag"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[1] - ⚠️ function calls are not analysed yet -- *4* ???*5*["dependencies"] - ⚠️ unknown object -- *5* arguments[0] - ⚠️ function calls are not analysed yet -- *6* ???*7*["key"] - ⚠️ unknown object -- *7* arguments[0] - ⚠️ function calls are not analysed yet -- *8* ???*9*["mode"] - ⚠️ unknown object -- *9* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6154 conditional = (null === (???*0* | ???*1*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["dependencies"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6163 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | ???*2*)) - ⚠️ nested operation -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -6163 -> 6164 call = (...) => !((!(a) || !(a["isReactComponent"])))((???*0* | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* unknown new expression +0 -> 6691 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +- *0* $i(a, b, e) + ⚠️ sequence with side effects ⚠️ This value might have side effects - -6163 -> 6165 conditional = ("string" === ???*0*) -- *0* typeof((???*1* | ???*2*)) - ⚠️ nested operation -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects - -6165 -> 6167 call = (...) => a(???*0*, (???*2* | ???*3*), ???*4*, (???*5* | ???*6*)) -- *0* ???*1*["children"] - ⚠️ unknown object -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[4] - ⚠️ function calls are not analysed yet -- *3* unsupported assign operation +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *4* arguments[5] - ⚠️ function calls are not analysed yet -- *5* arguments[1] - ⚠️ function calls are not analysed yet -- *6* unknown new expression +- *3* max number of linking steps reached + ⚠️ This value might have side effects +- *4* max number of linking steps reached + ⚠️ This value might have side effects +- *5* max number of linking steps reached ⚠️ This value might have side effects -6165 -> 6168 call = (...) => ???*0*(12, ???*1*, (???*2* | ???*3*), ???*4*) -- *0* unknown new expression +0 -> 6692 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* unknown new expression + +0 -> 6696 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *4* unsupported expression + +6696 -> 6697 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -6165 -> 6171 call = (...) => ???*0*(13, ???*1*, (???*2* | ???*3*), (???*4* | ???*5*)) -- *0* unknown new expression +0 -> 6698 call = (...) => kj(a, b, c, d, f, e)(???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *4* arguments[4] - ⚠️ function calls are not analysed yet -- *5* unsupported assign operation +- *2* max number of linking steps reached ⚠️ This value might have side effects - -6165 -> 6174 call = (...) => ???*0*(19, ???*1*, (???*2* | ???*3*), (???*4* | ???*5*)) -- *0* unknown new expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* unknown new expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *4* arguments[4] - ⚠️ function calls are not analysed yet -- *5* unsupported assign operation + +0 -> 6699 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -6165 -> 6177 call = (...) => a(???*0*, (???*1* | ???*2*), ???*3*, (???*4* | ???*5*)) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* arguments[4] - ⚠️ function calls are not analysed yet -- *2* unsupported assign operation +0 -> 6700 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[5] - ⚠️ function calls are not analysed yet -- *4* arguments[1] - ⚠️ function calls are not analysed yet -- *5* unknown new expression + +0 -> 6701 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -6165 -> 6178 conditional = (("object" === ???*0*) | (null !== (???*3* | ???*4*))) -- *0* typeof((???*1* | ???*2*)) +6701 -> 6702 free var = FreeVar(Error) + +6701 -> 6703 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(387) + +6701 -> 6704 call = ???*0*( + `Minified React error #${387}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global + ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${387}` ⚠️ nested operation -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression + +0 -> 6708 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -6165 -> 6180 free var = FreeVar(Error) - -6165 -> 6181 conditional = (null == (???*0* | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* unknown new expression +0 -> 6709 call = (...) => undefined(???*0*, ???*1*, null, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects - -6165 -> 6182 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(130, (???*0* ? (???*3* | ???*4*) : ???*5*), "") -- *0* (null == (???*1* | ???*2*)) - ⚠️ nested operation -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* unknown new expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *5* typeof((???*6* | ???*7*)) - ⚠️ nested operation -- *6* arguments[0] - ⚠️ function calls are not analysed yet -- *7* unknown new expression + +0 -> 6713 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -6165 -> 6183 call = ???*0*( - `Minified React error #${130}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +6713 -> 6721 free var = FreeVar(Error) + +6713 -> 6722 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(423) + +6713 -> 6723 call = ???*0*( + `Minified React error #${423}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${130}` +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${423}` ⚠️ nested operation -0 -> 6184 call = (...) => ???*0*((2 | 1 | 5 | 8 | 10 | 9 | 11 | 14 | 16), ???*1*, (???*2* | ???*3*), (???*4* | ???*5*)) -- *0* unknown new expression +6713 -> 6724 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*2*) +- *0* ???*1*(p(423)) + ⚠️ unknown callee ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* unknown new expression +- *1* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *4* arguments[4] - ⚠️ function calls are not analysed yet -- *5* unsupported assign operation +- *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6188 call = (...) => ???*0*(7, (???*1* | ???*2*), ???*3*, ???*4*) -- *0* unknown new expression - ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +6713 -> 6725 call = (...) => b["child"](???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[3] - ⚠️ function calls are not analysed yet -- *4* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 6190 call = (...) => ???*0*(22, (???*1* | ???*2*), ???*3*, ???*4*) -- *0* unknown new expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[3] - ⚠️ function calls are not analysed yet -- *4* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 6194 call = (...) => ???*0*(6, (???*1* | ???*2*), null, ???*3*) -- *0* unknown new expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *3* arguments[1] - ⚠️ function calls are not analysed yet -0 -> 6197 conditional = (null !== ???*0*) -- *0* ???*1*["children"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6200 call = (...) => ???*0*(4, (???*1* ? ???*4* : []), ???*6*, (???*8* | ???*9*)) -- *0* unknown new expression - ⚠️ This value might have side effects -- *1* (null !== ???*2*) - ⚠️ nested operation -- *2* ???*3*["children"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["children"] - ⚠️ unknown object -- *5* arguments[0] - ⚠️ function calls are not analysed yet -- *6* ???*7*["key"] - ⚠️ unknown object -- *7* arguments[0] - ⚠️ function calls are not analysed yet -- *8* arguments[1] - ⚠️ function calls are not analysed yet -- *9* unknown new expression +6713 -> 6726 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6217 call = (...) => b(0) - -0 -> 6219 call = (...) => b(???*0*) -- *0* unsupported expression - ⚠️ This value might have side effects +6726 -> 6727 free var = FreeVar(Error) -0 -> 6228 call = (...) => b(0) +6726 -> 6728 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(424) -0 -> 6232 conditional = (1 === (???*0* | 1 | ???*1* | 0)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* unsupported assign operation +6726 -> 6729 call = ???*0*( + `Minified React error #${424}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${424}` + ⚠️ nested operation -0 -> 6233 call = (...) => ???*0*(3, null, null, (???*1* | 1 | ???*2* | 0)) -- *0* unknown new expression +6726 -> 6730 call = (...) => {"value": a, "source": b, "stack": e, "digest": null}(???*0*, ???*2*) +- *0* ???*1*(p(424)) + ⚠️ unknown callee ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* unsupported assign operation +- *1* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects - -0 -> 6237 call = (...) => undefined((???*0* | ???*1*)) -- *0* arguments[5] - ⚠️ function calls are not analysed yet -- *1* unknown new expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6239 free var = FreeVar(arguments) - -0 -> 6241 free var = FreeVar(arguments) - -0 -> 6242 conditional = (???*0* | (???*1* !== ???*2*)) -- *0* unsupported expression +6726 -> 6731 call = (...) => b["child"](???*0*, ???*1*, ???*2*, ???*3*, ???*4*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* ???*3*[3] - ⚠️ unknown object +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *3* FreeVar(arguments) - ⚠️ unknown global +- *3* max number of linking steps reached + ⚠️ This value might have side effects +- *4* max number of linking steps reached ⚠️ This value might have side effects -6242 -> 6244 free var = FreeVar(arguments) - -0 -> 6245 conditional = (null == ???*0*) -- *0* ((???*1* | ???*2*) ? ???*6* : null) - ⚠️ nested operation -- *1* unsupported expression +6726 -> 6735 call = (...) => (null | a)(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* (???*3* !== ???*4*) - ⚠️ nested operation -- *3* unsupported expression + +6726 -> 6736 call = (...) => ( + | g(a) + | ???*0* + | n(a, d, f, h) + | t(a, d, f, h) + | (((("string" === typeof(f)) && ("" !== f)) || ("number" === typeof(f))) ? ???*1* : c(a, d)) +)(???*2*, null, ???*3*, ???*4*) +- *0* J(a, d, l(f["_payload"]), h) + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *4* ???*5*[3] - ⚠️ unknown object +- *1* g(a) + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *5* FreeVar(arguments) - ⚠️ unknown global +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *6* ???*7*[3] - ⚠️ unknown object +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *7* FreeVar(arguments) - ⚠️ unknown global +- *4* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6247 call = (...) => ((3 === b["tag"]) ? c : null)((???*0* | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["_reactInternals"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference - -0 -> 6249 conditional = ((???*0* !== (???*8* | ???*9*)) | (1 !== ???*11*)) -- *0* (???*1* ? (???*4* | ???*5* | ???*7*) : null) - ⚠️ nested operation -- *1* (3 === ???*2*) - ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* ???*6*["_reactInternals"] - ⚠️ unknown object -- *6* a - ⚠️ circular variable reference -- *7* a - ⚠️ circular variable reference -- *8* arguments[0] - ⚠️ function calls are not analysed yet -- *9* ???*10*["_reactInternals"] - ⚠️ unknown object -- *10* a - ⚠️ circular variable reference -- *11* ???*12*["tag"] - ⚠️ unknown object -- *12* arguments[0] - ⚠️ function calls are not analysed yet +6713 -> 6741 call = (...) => undefined() -6249 -> 6250 free var = FreeVar(Error) +6713 -> 6742 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -6249 -> 6251 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(170) +6742 -> 6743 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects -6249 -> 6252 call = ???*0*( - `Minified React error #${170}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +6713 -> 6744 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${170}` - ⚠️ nested operation -0 -> 6257 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) -- *0* unsupported expression +0 -> 6746 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* ???*2*["type"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -0 -> 6258 conditional = ((null !== ???*0*) | (???*2* !== ???*3*)) -- *0* ???*1*["type"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unsupported expression +0 -> 6747 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* ???*4*["type"] - ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet -0 -> 6262 free var = FreeVar(Error) +0 -> 6748 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6263 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(171) +0 -> 6751 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6264 call = ???*0*( - `Minified React error #${171}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +0 -> 6754 call = (...) => ( + || ("textarea" === a) + || ("noscript" === a) + || ("string" === typeof(b["children"])) + || ("number" === typeof(b["children"])) + || ( + && ("object" === typeof(b["dangerouslySetInnerHTML"])) + && (null !== b["dangerouslySetInnerHTML"]) + && (null != b["dangerouslySetInnerHTML"]["__html"]) + ) +)(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${171}` - ⚠️ nested operation -0 -> 6266 conditional = (1 === ???*0*) -- *0* ???*1*["tag"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 6755 conditional = ???*0* +- *0* max number of linking steps reached + ⚠️ This value might have side effects -6266 -> 6268 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) -- *0* unsupported expression +6755 -> 6756 call = (...) => ( + || ("textarea" === a) + || ("noscript" === a) + || ("string" === typeof(b["children"])) + || ("number" === typeof(b["children"])) + || ( + && ("object" === typeof(b["dangerouslySetInnerHTML"])) + && (null !== b["dangerouslySetInnerHTML"]) + && (null != b["dangerouslySetInnerHTML"]["__html"]) + ) +)(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *1* ???*2*["type"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -6266 -> 6269 conditional = ((null !== ???*0*) | (???*2* !== ???*3*)) -- *0* ???*1*["type"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unsupported expression +0 -> 6758 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *3* ???*4*["type"] - ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet -6269 -> 6270 call = (...) => (c | A({}, c, d))((???*0* | ???*1*), ???*3*, (???*5* | ???*6*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["_reactInternals"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* ???*4*["type"] - ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* arguments[0] - ⚠️ function calls are not analysed yet -- *6* ???*7*["_reactInternals"] - ⚠️ unknown object -- *7* a - ⚠️ circular variable reference +0 -> 6759 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached + ⚠️ This value might have side effects -0 -> 6271 call = (...) => a( - (???*0* | ???*1* | ???*3*), - (???*5* | (???*6* ? ???*8* : ???*9*)), - true, - (???*17* | ???*18* | ???*20*), - ( - | ???*21* - | 1 - | ???*22* - | ???*23* - | ???*24* - | ???*26* - | 0 - | ???*28* - | 4 - | ((???*29* | ???*31*) ? ???*32* : 4) - | (???*33* ? 16 : (???*34* | null | ???*41* | ???*42*)) - | (???*44* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - ( - | ???*47* - | { - "eventTime": (???*48* | (???*49* ? ???*51* : ???*52*)), - "lane": ( - | ???*60* - | 1 - | ???*61* - | ???*62* - | ???*63* - | ???*65* - | 0 - | ???*67* - | 4 - | ((???*68* | ???*70*) ? ???*71* : 4) - | (???*72* ? 16 : (???*73* | null | ???*80* | ???*81*)) - | (???*83* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - "tag": 0, - "payload": null, - "callback": null, - "next": null - } - ), - ???*86*, - ???*87*, - ???*88* -) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["current"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["current"] - ⚠️ unknown object +0 -> 6761 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *4* unknown new expression + +0 -> 6762 call = (...) => undefined(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* arguments[3] - ⚠️ function calls are not analysed yet -- *6* (0 !== ???*7*) - ⚠️ nested operation -- *7* unsupported expression + +0 -> 6763 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *8* module["unstable_now"]() - ⚠️ nested operation -- *9* (???*10* ? (???*14* | ???*15*) : ???*16*) - ⚠️ nested operation -- *10* (???*11* !== (???*12* | ???*13*)) - ⚠️ nested operation -- *11* unsupported expression + +0 -> 6764 call = (...) => (???*0* | (f ? ???*1* : rj(b, g)) | sj(a, b, g, d, h, e, c) | d)(???*2*, ???*3*, ???*4*) +- *0* null + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *12* unsupported expression +- *1* a + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *13* module["unstable_now"]() - ⚠️ nested operation -- *14* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *15* module["unstable_now"]() - ⚠️ nested operation -- *16* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *17* arguments[0] - ⚠️ function calls are not analysed yet -- *18* ???*19*["current"] - ⚠️ unknown object -- *19* a - ⚠️ circular variable reference -- *20* unknown new expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *21* arguments[4] - ⚠️ function calls are not analysed yet -- *22* unsupported expression + +0 -> 6765 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *23* Ck - ⚠️ sequence with side effects + +0 -> 6768 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *24* ???*25*["current"] - ⚠️ unknown object -- *25* arguments[0] - ⚠️ function calls are not analysed yet -- *26* ???*27*["current"] - ⚠️ unknown object +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *27* unknown new expression + +0 -> 6770 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *28* C - ⚠️ circular variable reference -- *29* (0 !== ???*30*) - ⚠️ nested operation -- *30* C - ⚠️ circular variable reference -- *31* unsupported expression + +6770 -> 6772 call = (...) => ( + | g(a) + | ???*0* + | n(a, d, f, h) + | t(a, d, f, h) + | (((("string" === typeof(f)) && ("" !== f)) || ("number" === typeof(f))) ? ???*1* : c(a, d)) +)(???*2*, null, ???*3*, ???*4*) +- *0* J(a, d, l(f["_payload"]), h) + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *32* C - ⚠️ circular variable reference -- *33* unsupported expression +- *1* g(a) + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *34* (???*35* ? ???*36* : 1) - ⚠️ nested operation -- *35* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *36* (???*37* ? ???*38* : 4) - ⚠️ nested operation -- *37* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *38* (???*39* ? 16 : 536870912) - ⚠️ nested operation -- *39* (0 !== ???*40*) - ⚠️ nested operation -- *40* unsupported expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *41* arguments[0] - ⚠️ function calls are not analysed yet -- *42* ???*43*["value"] - ⚠️ unknown object -- *43* arguments[1] - ⚠️ function calls are not analysed yet -- *44* (???*45* === ???*46*) - ⚠️ nested operation -- *45* unsupported expression + +6770 -> 6773 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *46* a - ⚠️ circular variable reference -- *47* arguments[5] - ⚠️ function calls are not analysed yet -- *48* arguments[3] - ⚠️ function calls are not analysed yet -- *49* (0 !== ???*50*) - ⚠️ nested operation -- *50* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *51* module["unstable_now"]() - ⚠️ nested operation -- *52* (???*53* ? (???*57* | ???*58*) : ???*59*) - ⚠️ nested operation -- *53* (???*54* !== (???*55* | ???*56*)) - ⚠️ nested operation -- *54* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *55* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *56* module["unstable_now"]() - ⚠️ nested operation -- *57* unsupported expression + +0 -> 6775 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *58* module["unstable_now"]() - ⚠️ nested operation -- *59* unsupported expression + +0 -> 6779 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *60* arguments[4] - ⚠️ function calls are not analysed yet -- *61* unsupported expression + +6779 -> 6780 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *62* Ck +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6781 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +- *0* $i(a, b, e) ⚠️ sequence with side effects ⚠️ This value might have side effects -- *63* ???*64*["current"] - ⚠️ unknown object -- *64* arguments[0] - ⚠️ function calls are not analysed yet -- *65* ???*66*["current"] - ⚠️ unknown object +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *66* unknown new expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *67* C - ⚠️ circular variable reference -- *68* (0 !== ???*69*) - ⚠️ nested operation -- *69* C - ⚠️ circular variable reference -- *70* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *71* C - ⚠️ circular variable reference -- *72* unsupported expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *73* (???*74* ? ???*75* : 1) - ⚠️ nested operation -- *74* unsupported expression +- *5* max number of linking steps reached ⚠️ This value might have side effects -- *75* (???*76* ? ???*77* : 4) - ⚠️ nested operation -- *76* unsupported expression + +0 -> 6782 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *77* (???*78* ? 16 : 536870912) - ⚠️ nested operation -- *78* (0 !== ???*79*) - ⚠️ nested operation -- *79* unsupported expression + +0 -> 6784 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *80* arguments[0] - ⚠️ function calls are not analysed yet -- *81* ???*82*["value"] - ⚠️ unknown object -- *82* arguments[1] - ⚠️ function calls are not analysed yet -- *83* (???*84* === ???*85*) - ⚠️ nested operation -- *84* unsupported expression +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *85* a - ⚠️ circular variable reference -- *86* arguments[6] - ⚠️ function calls are not analysed yet -- *87* arguments[7] - ⚠️ function calls are not analysed yet -- *88* arguments[8] - ⚠️ function calls are not analysed yet -0 -> 6273 call = (...) => (Vf | bg(a, c, b) | b)(null) +0 -> 6786 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 6275 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression +0 -> 6789 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* unsupported expression +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6276 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3* | ???*5*)) -- *0* unsupported expression +0 -> 6791 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* Ck - ⚠️ sequence with side effects + +0 -> 6794 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* arguments[2] - ⚠️ function calls are not analysed yet -- *3* ???*4*["current"] - ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* ???*6*["current"] - ⚠️ unknown object +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *6* unknown new expression +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6277 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( - (???*0* | (???*1* ? ???*3* : ???*4*)), - ( - | ???*12* - | 1 - | ???*13* - | ???*14* - | ???*15* - | ???*17* - | 0 - | ???*19* - | 4 - | ((???*20* | ???*22*) ? ???*23* : 4) - | (???*24* ? 16 : (???*25* | null | ???*32* | ???*33*)) - | (???*35* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ) -) -- *0* arguments[3] - ⚠️ function calls are not analysed yet -- *1* (0 !== ???*2*) - ⚠️ nested operation -- *2* unsupported expression +0 -> 6796 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *3* module["unstable_now"]() - ⚠️ nested operation -- *4* (???*5* ? (???*9* | ???*10*) : ???*11*) - ⚠️ nested operation -- *5* (???*6* !== (???*7* | ???*8*)) - ⚠️ nested operation -- *6* unsupported expression + +0 -> 6803 call = (...) => undefined({"current": null}, ???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *7* unsupported expression + +0 -> 6805 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *8* module["unstable_now"]() + +6805 -> 6807 call = (???*0* ? ???*4* : (...) => ???*6*)(???*9*, ???*10*) +- *0* ("function" === ???*1*) ⚠️ nested operation -- *9* unsupported expression - ⚠️ This value might have side effects -- *10* module["unstable_now"]() +- *1* typeof(???*2*) ⚠️ nested operation -- *11* unsupported expression - ⚠️ This value might have side effects -- *12* arguments[4] - ⚠️ function calls are not analysed yet -- *13* unsupported expression +- *2* ???*3*["is"] + ⚠️ unknown object ⚠️ This value might have side effects -- *14* Ck - ⚠️ sequence with side effects +- *3* FreeVar(Object) + ⚠️ unknown global ⚠️ This value might have side effects -- *15* ???*16*["current"] - ⚠️ unknown object -- *16* arguments[0] - ⚠️ function calls are not analysed yet -- *17* ???*18*["current"] +- *4* ???*5*["is"] ⚠️ unknown object ⚠️ This value might have side effects -- *18* unknown new expression +- *5* FreeVar(Object) + ⚠️ unknown global ⚠️ This value might have side effects -- *19* C - ⚠️ circular variable reference -- *20* (0 !== ???*21*) +- *6* (((a === b) && ((0 !== a) || (???*7* === ???*8*))) || ((a !== a) && (b !== b))) ⚠️ nested operation -- *21* C - ⚠️ circular variable reference -- *22* unsupported expression +- *7* unsupported expression ⚠️ This value might have side effects -- *23* C - ⚠️ circular variable reference -- *24* unsupported expression +- *8* unsupported expression ⚠️ This value might have side effects -- *25* (???*26* ? ???*27* : 1) - ⚠️ nested operation -- *26* unsupported expression +- *9* max number of linking steps reached ⚠️ This value might have side effects -- *27* (???*28* ? ???*29* : 4) - ⚠️ nested operation -- *28* unsupported expression +- *10* max number of linking steps reached ⚠️ This value might have side effects -- *29* (???*30* ? 16 : 536870912) - ⚠️ nested operation -- *30* (0 !== ???*31*) - ⚠️ nested operation -- *31* unsupported expression + +6805 -> 6808 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *32* arguments[0] - ⚠️ function calls are not analysed yet -- *33* ???*34*["value"] - ⚠️ unknown object -- *34* arguments[1] - ⚠️ function calls are not analysed yet -- *35* (???*36* === ???*37*) - ⚠️ nested operation -- *36* unsupported expression + +6808 -> 6812 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *37* a - ⚠️ circular variable reference -0 -> 6279 conditional = ((???*0* !== ???*1*) | (null !== ???*2*)) -- *0* unsupported expression +6812 -> 6813 call = (...) => (null | b["child"])(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -0 -> 6280 call = (...) => (null | Zg(a, c))( - (???*0* | ???*1* | ???*3*), - ( - | ???*5* - | { - "eventTime": (???*6* | (???*7* ? ???*9* : ???*10*)), - "lane": ( - | ???*18* - | 1 - | ???*19* - | ???*20* - | ???*21* - | ???*23* - | 0 - | ???*25* - | 4 - | ((???*26* | ???*28*) ? ???*29* : 4) - | (???*30* ? 16 : (???*31* | null | ???*38* | ???*39*)) - | (???*41* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - "tag": 0, - "payload": null, - "callback": null, - "next": null - } - ), - ( - | ???*44* - | 1 - | ???*45* - | ???*46* - | ???*47* - | ???*49* - | 0 - | ???*51* - | 4 - | ((???*52* | ???*54*) ? ???*55* : 4) - | (???*56* ? 16 : (???*57* | null | ???*64* | ???*65*)) - | (???*67* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ) -) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["current"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["current"] - ⚠️ unknown object +6808 -> 6817 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *4* unknown new expression + +6817 -> 6821 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* arguments[5] - ⚠️ function calls are not analysed yet -- *6* arguments[3] - ⚠️ function calls are not analysed yet -- *7* (0 !== ???*8*) - ⚠️ nested operation -- *8* unsupported expression + +6821 -> 6823 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *9* module["unstable_now"]() - ⚠️ nested operation -- *10* (???*11* ? (???*15* | ???*16*) : ???*17*) - ⚠️ nested operation -- *11* (???*12* !== (???*13* | ???*14*)) - ⚠️ nested operation -- *12* unsupported expression + +6823 -> 6824 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}(???*0*, ???*1*) +- *0* unsupported expression ⚠️ This value might have side effects -- *13* unsupported expression +- *1* unsupported expression ⚠️ This value might have side effects -- *14* module["unstable_now"]() - ⚠️ nested operation -- *15* unsupported expression + +6823 -> 6827 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *16* module["unstable_now"]() - ⚠️ nested operation -- *17* unsupported expression + +6827 -> 6830 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *18* arguments[4] - ⚠️ function calls are not analysed yet -- *19* unsupported expression + +6821 -> 6840 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *20* Ck - ⚠️ sequence with side effects +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *21* ???*22*["current"] - ⚠️ unknown object -- *22* arguments[0] - ⚠️ function calls are not analysed yet -- *23* ???*24*["current"] - ⚠️ unknown object +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *24* unknown new expression + +6817 -> 6844 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *25* C - ⚠️ circular variable reference -- *26* (0 !== ???*27*) - ⚠️ nested operation -- *27* C - ⚠️ circular variable reference -- *28* unsupported expression + +6844 -> 6847 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *29* C - ⚠️ circular variable reference -- *30* unsupported expression + +6844 -> 6850 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *31* (???*32* ? ???*33* : 1) - ⚠️ nested operation -- *32* unsupported expression + +6850 -> 6852 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *33* (???*34* ? ???*35* : 4) - ⚠️ nested operation -- *34* unsupported expression + +6852 -> 6853 free var = FreeVar(Error) + +6852 -> 6854 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(341) + +6852 -> 6855 call = ???*0*( + `Minified React error #${341}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *35* (???*36* ? 16 : 536870912) - ⚠️ nested operation -- *36* (0 !== ???*37*) +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${341}` ⚠️ nested operation -- *37* unsupported expression + +6850 -> 6859 call = (...) => undefined(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *38* arguments[0] - ⚠️ function calls are not analysed yet -- *39* ???*40*["value"] - ⚠️ unknown object -- *40* arguments[1] - ⚠️ function calls are not analysed yet -- *41* (???*42* === ???*43*) - ⚠️ nested operation -- *42* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *43* a - ⚠️ circular variable reference -- *44* arguments[4] - ⚠️ function calls are not analysed yet -- *45* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *46* Ck - ⚠️ sequence with side effects + +6808 -> 6862 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *47* ???*48*["current"] - ⚠️ unknown object -- *48* arguments[0] - ⚠️ function calls are not analysed yet -- *49* ???*50*["current"] - ⚠️ unknown object + +6862 -> 6865 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *50* unknown new expression + +0 -> 6870 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *51* C - ⚠️ circular variable reference -- *52* (0 !== ???*53*) - ⚠️ nested operation -- *53* C - ⚠️ circular variable reference -- *54* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *55* C - ⚠️ circular variable reference -- *56* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *57* (???*58* ? ???*59* : 1) - ⚠️ nested operation -- *58* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *59* (???*60* ? ???*61* : 4) - ⚠️ nested operation -- *60* unsupported expression + +0 -> 6872 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *61* (???*62* ? 16 : 536870912) - ⚠️ nested operation -- *62* (0 !== ???*63*) - ⚠️ nested operation -- *63* unsupported expression + +0 -> 6876 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *64* arguments[0] - ⚠️ function calls are not analysed yet -- *65* ???*66*["value"] - ⚠️ unknown object -- *66* arguments[1] - ⚠️ function calls are not analysed yet -- *67* (???*68* === ???*69*) - ⚠️ nested operation -- *68* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *69* a - ⚠️ circular variable reference -0 -> 6283 call = (...) => undefined( - (???*0* | ???*1* | ???*3*), - ( - | ???*4* - | 1 - | ???*5* - | ???*6* - | ???*7* - | ???*9* - | 0 - | ???*11* - | 4 - | ((???*12* | ???*14*) ? ???*15* : 4) - | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) - | (???*27* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - (???*30* | (???*31* ? ???*33* : ???*34*)) -) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["current"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* unknown new expression +0 -> 6877 call = (...) => b(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6878 call = ???*0*(???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6880 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *4* arguments[4] - ⚠️ function calls are not analysed yet -- *5* unsupported expression + +0 -> 6882 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *6* Ck + +0 -> 6885 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6887 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6888 call = (...) => (???*0* | ???*1* | $i(a, b, e))(???*2*, ???*3*, ???*4*, ???*5*, ???*6*) +- *0* cj(a, b, f, d, e) ⚠️ sequence with side effects ⚠️ This value might have side effects -- *7* ???*8*["current"] - ⚠️ unknown object -- *8* arguments[0] - ⚠️ function calls are not analysed yet -- *9* ???*10*["current"] - ⚠️ unknown object +- *1* unsupported expression ⚠️ This value might have side effects -- *10* unknown new expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *11* C - ⚠️ circular variable reference -- *12* (0 !== ???*13*) - ⚠️ nested operation -- *13* C - ⚠️ circular variable reference -- *14* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *15* C - ⚠️ circular variable reference -- *16* unsupported expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *17* (???*18* ? ???*19* : 1) - ⚠️ nested operation -- *18* unsupported expression +- *5* max number of linking steps reached ⚠️ This value might have side effects -- *19* (???*20* ? ???*21* : 4) - ⚠️ nested operation -- *20* unsupported expression +- *6* max number of linking steps reached ⚠️ This value might have side effects -- *21* (???*22* ? 16 : 536870912) - ⚠️ nested operation -- *22* (0 !== ???*23*) - ⚠️ nested operation -- *23* unsupported expression + +0 -> 6889 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *24* arguments[0] - ⚠️ function calls are not analysed yet -- *25* ???*26*["value"] - ⚠️ unknown object -- *26* arguments[1] - ⚠️ function calls are not analysed yet -- *27* (???*28* === ???*29*) - ⚠️ nested operation -- *28* unsupported expression + +0 -> 6892 call = (...) => (???*0* | dj(a, b, c, d, e))(???*1*, ???*2*, ???*3*, ???*4*, ???*5*) +- *0* $i(a, b, e) + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *29* a - ⚠️ circular variable reference -- *30* arguments[3] - ⚠️ function calls are not analysed yet -- *31* (0 !== ???*32*) - ⚠️ nested operation -- *32* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *33* module["unstable_now"]() - ⚠️ nested operation -- *34* (???*35* ? (???*39* | ???*40*) : ???*41*) - ⚠️ nested operation -- *35* (???*36* !== (???*37* | ???*38*)) - ⚠️ nested operation -- *36* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *37* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *38* module["unstable_now"]() - ⚠️ nested operation -- *39* unsupported expression +- *4* max number of linking steps reached ⚠️ This value might have side effects -- *40* module["unstable_now"]() - ⚠️ nested operation -- *41* unsupported expression +- *5* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6284 call = (...) => undefined((???*0* | ???*1* | ???*3*), (???*4* | (???*5* ? ???*7* : ???*8*))) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["current"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* unknown new expression +0 -> 6893 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *4* arguments[3] - ⚠️ function calls are not analysed yet -- *5* (0 !== ???*6*) - ⚠️ nested operation -- *6* unsupported expression + +0 -> 6897 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *7* module["unstable_now"]() - ⚠️ nested operation -- *8* (???*9* ? (???*13* | ???*14*) : ???*15*) - ⚠️ nested operation -- *9* (???*10* !== (???*11* | ???*12*)) - ⚠️ nested operation -- *10* unsupported expression + +6897 -> 6898 call = (...) => b(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *11* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *12* module["unstable_now"]() - ⚠️ nested operation -- *13* unsupported expression + +0 -> 6899 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *14* module["unstable_now"]() - ⚠️ nested operation -- *15* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6286 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +0 -> 6901 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) - *0* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression - ⚠️ This value might have side effects -- *2* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6287 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*4* | ???*5*)) -- *0* unsupported expression +0 -> 6902 conditional = ???*0* +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* Ck - ⚠️ sequence with side effects + +6902 -> 6903 call = (...) => !(0)(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* ???*3*["current"] - ⚠️ unknown object -- *3* arguments[1] - ⚠️ function calls are not analysed yet -- *4* FreeVar(undefined) - ⚠️ unknown global + +0 -> 6904 call = (...) => undefined(???*0*, ???*1*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* unknown mutation +- *1* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6288 call = (...) => (Vf | bg(a, c, b) | b)((???*0* | {} | ???*1* | ???*2* | ???*4*)) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* c - ⚠️ circular variable reference -- *2* ???*3*["_reactInternals"] - ⚠️ unknown object -- *3* a - ⚠️ circular variable reference -- *4* ???*5*({}, c, d) - ⚠️ unknown callee +0 -> 6905 call = (...) => b(???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *5* ???*6*["assign"] - ⚠️ unknown object +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *6* FreeVar(Object) - ⚠️ unknown global +- *2* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6290 conditional = (null === (???*0* | ???*2* | ???*3*)) -- *0* ???*1*["context"] - ⚠️ unknown object -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* FreeVar(undefined) - ⚠️ unknown global +0 -> 6906 call = (...) => undefined(???*0*, ???*1*, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *3* unknown mutation +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects +- *3* max number of linking steps reached ⚠️ This value might have side effects -0 -> 6293 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( - (???*0* ? ???*2* : ???*3*), - ( - | 1 - | ???*11* - | ???*12* - | ???*13* - | ???*15* - | ???*16* - | 0 - | ???*17* - | 4 - | ((???*18* | ???*20*) ? ???*21* : 4) - | (???*22* ? 16 : (???*23* | null | ???*30* | ???*31*)) - | ???*33* - | ???*34* - | (???*36* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ) -) -- *0* (0 !== ???*1*) - ⚠️ nested operation -- *1* unsupported expression +0 -> 6907 call = (...) => ($i(a, b, f) | b["child"])(null, ???*0*, ???*1*, true, ???*2*, ???*3*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *2* module["unstable_now"]() - ⚠️ nested operation -- *3* (???*4* ? (???*8* | ???*9*) : ???*10*) - ⚠️ nested operation -- *4* (???*5* !== (???*6* | ???*7*)) - ⚠️ nested operation -- *5* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *6* unsupported expression +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *7* module["unstable_now"]() - ⚠️ nested operation -- *8* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *9* module["unstable_now"]() - ⚠️ nested operation -- *10* unsupported expression + +0 -> 6908 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *11* unsupported expression + +0 -> 6909 call = (...) => b["child"](???*0*, ???*1*, ???*2*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *12* Ck +- *1* max number of linking steps reached + ⚠️ This value might have side effects +- *2* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6910 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6911 call = (...) => (???*0* | b["child"])(???*1*, ???*2*, ???*3*) +- *0* null ⚠️ sequence with side effects ⚠️ This value might have side effects -- *13* ???*14*["current"] - ⚠️ unknown object -- *14* arguments[1] - ⚠️ function calls are not analysed yet -- *15* FreeVar(undefined) - ⚠️ unknown global +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *16* unknown mutation +- *2* max number of linking steps reached ⚠️ This value might have side effects -- *17* C - ⚠️ circular variable reference -- *18* (0 !== ???*19*) - ⚠️ nested operation -- *19* C - ⚠️ circular variable reference -- *20* unsupported expression +- *3* max number of linking steps reached ⚠️ This value might have side effects -- *21* C - ⚠️ circular variable reference -- *22* unsupported expression + +0 -> 6912 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *23* (???*24* ? ???*25* : 1) - ⚠️ nested operation -- *24* unsupported expression + +0 -> 6913 free var = FreeVar(Error) + +0 -> 6915 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(156, ???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *25* (???*26* ? ???*27* : 4) - ⚠️ nested operation -- *26* unsupported expression + +0 -> 6916 call = ???*0*(???*1*) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *27* (???*28* ? 16 : 536870912) +- *1* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 6917 call = module["unstable_scheduleCallback"](???*0*, ???*1*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 6918 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6941 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6944 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 6945 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | ???*2*)) ⚠️ nested operation -- *28* (0 !== ???*29*) +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["$$typeof"] + ⚠️ unknown object +- *3* a + ⚠️ circular variable reference + +6945 -> 6946 call = (...) => !((!(a) || !(a["isReactComponent"])))((???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["$$typeof"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference + +6945 -> 6947 conditional = !(???*0*) +- *0* !((???*1* | ???*2*)) ⚠️ nested operation -- *29* unsupported expression +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* ???*3*["$$typeof"] + ⚠️ unknown object +- *3* a + ⚠️ circular variable reference + +6945 -> 6948 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *30* arguments[0] + +6945 -> 6949 conditional = ((???*0* !== (???*1* | ???*2*)) | (null !== (???*4* | ???*5*))) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *31* ???*32*["value"] +- *2* ???*3*["$$typeof"] ⚠️ unknown object -- *32* arguments[1] +- *3* a + ⚠️ circular variable reference +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *33* arguments[0] +- *5* ???*6*["$$typeof"] + ⚠️ unknown object +- *6* a + ⚠️ circular variable reference + +6949 -> 6951 conditional = ((???*0* | ???*1*) === ???*3*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *34* ???*35*["event"] +- *1* ???*2*["$$typeof"] ⚠️ unknown object +- *2* a + ⚠️ circular variable reference +- *3* ???*4*["for"]("react.forward_ref") + ⚠️ unknown callee object ⚠️ This value might have side effects -- *35* FreeVar(window) +- *4* FreeVar(Symbol) ⚠️ unknown global ⚠️ This value might have side effects -- *36* (???*37* === ???*38*) - ⚠️ nested operation -- *37* unsupported expression + +6951 -> 6952 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *38* a + +6951 -> 6953 conditional = ((???*0* | ???*1*) === ???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["$$typeof"] + ⚠️ unknown object +- *2* a ⚠️ circular variable reference +- *3* ???*4*["for"]("react.memo") + ⚠️ unknown callee object + ⚠️ This value might have side effects +- *4* FreeVar(Symbol) + ⚠️ unknown global + ⚠️ This value might have side effects -0 -> 6295 conditional = (???*0* === (???*1* | ???*2*)) -- *0* unsupported expression +6953 -> 6954 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[3] - ⚠️ function calls are not analysed yet -- *2* (???*3* ? null : ???*6*) - ⚠️ nested operation -- *3* (???*4* === ???*5*) - ⚠️ nested operation -- *4* unsupported expression + +6945 -> 6955 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *5* d - ⚠️ circular variable reference -- *6* d - ⚠️ circular variable reference -0 -> 6297 call = (...) => (null | Zg(a, c))( - (???*0* | ???*2* | ???*3*), - ( - | ???*4* - | { - "eventTime": (???*5* ? ???*7* : ???*8*), - "lane": ( - | 1 - | ???*16* - | ???*17* - | ???*18* - | 0 - | ???*20* - | 4 - | ((???*21* | ???*23*) ? ???*24* : 4) - | (???*25* ? 16 : (???*26* | null | ???*33* | ???*34*)) - | ???*36* - | ???*37* - | (???*39* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - "tag": 0, - "payload": null, - "callback": null, - "next": null - } - ), - ( - | 1 - | ???*42* - | ???*43* - | ???*44* - | ???*46* - | ???*47* - | 0 - | ???*48* - | 4 - | ((???*49* | ???*51*) ? ???*52* : 4) - | (???*53* ? 16 : (???*54* | null | ???*61* | ???*62*)) - | ???*64* - | ???*65* - | (???*67* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ) -) -- *0* ???*1*["current"] +0 -> 6957 conditional = (null === (???*0* | ???*2*)) +- *0* ???*1*["alternate"] ⚠️ unknown object -- *1* arguments[1] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* FreeVar(undefined) - ⚠️ unknown global +- *2* unknown new expression ⚠️ This value might have side effects -- *3* unknown mutation + +6957 -> 6961 call = (...) => ???*0*(???*1*, (???*3* | ???*4*), ???*6*, ???*8*) +- *0* unknown new expression ⚠️ This value might have side effects -- *4* arguments[1] +- *1* ???*2*["tag"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *5* (0 !== ???*6*) - ⚠️ nested operation -- *6* unsupported expression +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* ???*5*["dependencies"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["key"] + ⚠️ unknown object +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* ???*9*["mode"] + ⚠️ unknown object +- *9* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 6992 conditional = (null === (???*0* | ???*1*)) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* ???*2*["dependencies"] + ⚠️ unknown object +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 7001 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *7* module["unstable_now"]() - ⚠️ nested operation -- *8* (???*9* ? (???*13* | ???*14*) : ???*15*) - ⚠️ nested operation -- *9* (???*10* !== (???*11* | ???*12*)) + +0 -> 7002 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | ???*2*)) ⚠️ nested operation -- *10* unsupported expression +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unknown new expression ⚠️ This value might have side effects -- *11* unsupported expression + +7002 -> 7003 call = (...) => !((!(a) || !(a["isReactComponent"])))((???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* unknown new expression ⚠️ This value might have side effects -- *12* module["unstable_now"]() + +7002 -> 7004 conditional = ("string" === ???*0*) +- *0* typeof((???*1* | ???*2*)) ⚠️ nested operation -- *13* unsupported expression +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unknown new expression ⚠️ This value might have side effects -- *14* module["unstable_now"]() - ⚠️ nested operation -- *15* unsupported expression + +7004 -> 7006 call = (...) => a(???*0*, (???*2* | ???*3*), ???*4*, (???*5* | ???*6*)) +- *0* ???*1*["children"] + ⚠️ unknown object +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* arguments[4] + ⚠️ function calls are not analysed yet +- *3* unsupported assign operation ⚠️ This value might have side effects -- *16* unsupported expression +- *4* arguments[5] + ⚠️ function calls are not analysed yet +- *5* arguments[1] + ⚠️ function calls are not analysed yet +- *6* unknown new expression ⚠️ This value might have side effects -- *17* Ck - ⚠️ sequence with side effects + +7004 -> 7007 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *18* ???*19*["current"] - ⚠️ unknown object -- *19* b - ⚠️ circular variable reference -- *20* C - ⚠️ circular variable reference -- *21* (0 !== ???*22*) - ⚠️ nested operation -- *22* C - ⚠️ circular variable reference -- *23* unsupported expression + +7004 -> 7008 call = (...) => ???*0*(12, ???*1*, (???*2* | ???*3*), ???*4*) +- *0* unknown new expression ⚠️ This value might have side effects -- *24* C - ⚠️ circular variable reference -- *25* unsupported expression +- *1* arguments[2] + ⚠️ function calls are not analysed yet +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* unknown new expression ⚠️ This value might have side effects -- *26* (???*27* ? ???*28* : 1) - ⚠️ nested operation -- *27* unsupported expression +- *4* unsupported expression ⚠️ This value might have side effects -- *28* (???*29* ? ???*30* : 4) - ⚠️ nested operation -- *29* unsupported expression + +7004 -> 7011 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *30* (???*31* ? 16 : 536870912) - ⚠️ nested operation -- *31* (0 !== ???*32*) - ⚠️ nested operation -- *32* unsupported expression + +7004 -> 7012 call = (...) => ???*0*(13, ???*1*, (???*2* | ???*3*), (???*4* | ???*5*)) +- *0* unknown new expression ⚠️ This value might have side effects -- *33* arguments[0] - ⚠️ function calls are not analysed yet -- *34* ???*35*["value"] - ⚠️ unknown object -- *35* arguments[1] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *36* arguments[0] +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *37* ???*38*["event"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *38* FreeVar(window) - ⚠️ unknown global +- *3* unknown new expression ⚠️ This value might have side effects -- *39* (???*40* === ???*41*) - ⚠️ nested operation -- *40* unsupported expression +- *4* arguments[4] + ⚠️ function calls are not analysed yet +- *5* unsupported assign operation ⚠️ This value might have side effects -- *41* a - ⚠️ circular variable reference -- *42* unsupported expression + +7004 -> 7015 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *43* Ck - ⚠️ sequence with side effects + +7004 -> 7016 call = (...) => ???*0*(19, ???*1*, (???*2* | ???*3*), (???*4* | ???*5*)) +- *0* unknown new expression ⚠️ This value might have side effects -- *44* ???*45*["current"] - ⚠️ unknown object -- *45* arguments[1] +- *1* arguments[2] ⚠️ function calls are not analysed yet -- *46* FreeVar(undefined) - ⚠️ unknown global +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* unknown new expression ⚠️ This value might have side effects -- *47* unknown mutation +- *4* arguments[4] + ⚠️ function calls are not analysed yet +- *5* unsupported assign operation ⚠️ This value might have side effects -- *48* C - ⚠️ circular variable reference -- *49* (0 !== ???*50*) - ⚠️ nested operation -- *50* C - ⚠️ circular variable reference -- *51* unsupported expression + +7004 -> 7019 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *52* C - ⚠️ circular variable reference -- *53* unsupported expression + +7004 -> 7020 call = (...) => a(???*0*, (???*1* | ???*2*), ???*3*, (???*4* | ???*5*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* arguments[4] + ⚠️ function calls are not analysed yet +- *2* unsupported assign operation ⚠️ This value might have side effects -- *54* (???*55* ? ???*56* : 1) - ⚠️ nested operation -- *55* unsupported expression +- *3* arguments[5] + ⚠️ function calls are not analysed yet +- *4* arguments[1] + ⚠️ function calls are not analysed yet +- *5* unknown new expression ⚠️ This value might have side effects -- *56* (???*57* ? ???*58* : 4) - ⚠️ nested operation -- *57* unsupported expression + +7004 -> 7021 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *58* (???*59* ? 16 : 536870912) - ⚠️ nested operation -- *59* (0 !== ???*60*) + +7004 -> 7022 conditional = (("object" === ???*0*) | (null !== (???*3* | ???*4*))) +- *0* typeof((???*1* | ???*2*)) ⚠️ nested operation -- *60* unsupported expression +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unknown new expression ⚠️ This value might have side effects -- *61* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *62* ???*63*["value"] - ⚠️ unknown object -- *63* arguments[1] +- *4* unknown new expression + ⚠️ This value might have side effects + +7004 -> 7024 free var = FreeVar(Error) + +7004 -> 7025 conditional = (null == (???*0* | ???*1*)) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *64* arguments[0] +- *1* unknown new expression + ⚠️ This value might have side effects + +7004 -> 7026 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(130, (???*0* ? (???*3* | ???*4*) : ???*5*), "") +- *0* (null == (???*1* | ???*2*)) + ⚠️ nested operation +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *65* ???*66*["event"] - ⚠️ unknown object +- *2* unknown new expression ⚠️ This value might have side effects -- *66* FreeVar(window) - ⚠️ unknown global +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* unknown new expression ⚠️ This value might have side effects -- *67* (???*68* === ???*69*) +- *5* typeof((???*6* | ???*7*)) ⚠️ nested operation -- *68* unsupported expression +- *6* arguments[0] + ⚠️ function calls are not analysed yet +- *7* unknown new expression ⚠️ This value might have side effects -- *69* a - ⚠️ circular variable reference -0 -> 6298 call = (...) => undefined( - ???*0*, - (???*1* | ???*3* | ???*4*), - ( - | 1 - | ???*5* - | ???*6* - | ???*7* - | ???*9* - | ???*10* - | 0 - | ???*11* - | 4 - | ((???*12* | ???*14*) ? ???*15* : 4) - | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) - | ???*27* - | ???*28* - | (???*30* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - (???*33* ? ???*35* : ???*36*) +7004 -> 7027 call = ???*0*( + `Minified React error #${130}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` ) -- *0* max number of linking steps reached +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *1* ???*2*["current"] - ⚠️ unknown object +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${130}` + ⚠️ nested operation + +0 -> 7028 call = (...) => ???*0*((2 | 1 | 5 | 8 | 10 | 9 | 11 | 14 | 16), ???*1*, (???*2* | ???*3*), (???*4* | ???*5*)) +- *0* unknown new expression + ⚠️ This value might have side effects +- *1* arguments[2] + ⚠️ function calls are not analysed yet - *2* arguments[1] ⚠️ function calls are not analysed yet -- *3* FreeVar(undefined) - ⚠️ unknown global +- *3* unknown new expression ⚠️ This value might have side effects -- *4* unknown mutation +- *4* arguments[4] + ⚠️ function calls are not analysed yet +- *5* unsupported assign operation ⚠️ This value might have side effects -- *5* unsupported expression + +0 -> 7032 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *6* Ck - ⚠️ sequence with side effects + +0 -> 7033 call = (...) => ???*0*(7, (???*1* | ???*2*), ???*3*, ???*4*) +- *0* unknown new expression ⚠️ This value might have side effects -- *7* ???*8*["current"] - ⚠️ unknown object -- *8* arguments[1] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *9* FreeVar(undefined) - ⚠️ unknown global +- *2* unknown new expression ⚠️ This value might have side effects -- *10* unknown mutation +- *3* arguments[3] + ⚠️ function calls are not analysed yet +- *4* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 7035 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *11* C - ⚠️ circular variable reference -- *12* (0 !== ???*13*) - ⚠️ nested operation -- *13* C - ⚠️ circular variable reference -- *14* unsupported expression + +0 -> 7036 call = (...) => ???*0*(22, (???*1* | ???*2*), ???*3*, ???*4*) +- *0* unknown new expression ⚠️ This value might have side effects -- *15* C - ⚠️ circular variable reference -- *16* unsupported expression +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unknown new expression ⚠️ This value might have side effects -- *17* (???*18* ? ???*19* : 1) - ⚠️ nested operation -- *18* unsupported expression +- *3* arguments[3] + ⚠️ function calls are not analysed yet +- *4* arguments[1] + ⚠️ function calls are not analysed yet + +0 -> 7040 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *19* (???*20* ? ???*21* : 4) - ⚠️ nested operation -- *20* unsupported expression + +0 -> 7041 call = (...) => ???*0*(6, (???*1* | ???*2*), null, ???*3*) +- *0* unknown new expression ⚠️ This value might have side effects -- *21* (???*22* ? 16 : 536870912) - ⚠️ nested operation -- *22* (0 !== ???*23*) - ⚠️ nested operation -- *23* unsupported expression +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unknown new expression ⚠️ This value might have side effects -- *24* arguments[0] +- *3* arguments[1] ⚠️ function calls are not analysed yet -- *25* ???*26*["value"] + +0 -> 7043 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 7045 conditional = (null !== ???*0*) +- *0* ???*1*["children"] ⚠️ unknown object -- *26* arguments[1] +- *1* arguments[0] ⚠️ function calls are not analysed yet -- *27* arguments[0] + +0 -> 7048 call = (...) => ???*0*(4, (???*1* ? ???*4* : []), ???*6*, (???*8* | ???*9*)) +- *0* unknown new expression + ⚠️ This value might have side effects +- *1* (null !== ???*2*) + ⚠️ nested operation +- *2* ???*3*["children"] + ⚠️ unknown object +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *28* ???*29*["event"] +- *4* ???*5*["children"] + ⚠️ unknown object +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["key"] ⚠️ unknown object +- *7* arguments[0] + ⚠️ function calls are not analysed yet +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* unknown new expression ⚠️ This value might have side effects -- *29* FreeVar(window) - ⚠️ unknown global + +0 -> 7053 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *30* (???*31* === ???*32*) - ⚠️ nested operation -- *31* unsupported expression + +0 -> 7066 call = (...) => b(0) + +0 -> 7068 call = (...) => b(???*0*) +- *0* unsupported expression ⚠️ This value might have side effects -- *32* a - ⚠️ circular variable reference -- *33* (0 !== ???*34*) - ⚠️ nested operation -- *34* unsupported expression + +0 -> 7077 call = (...) => b(0) + +0 -> 7081 conditional = (1 === (???*0* | 1 | ???*1* | 0)) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* unsupported assign operation ⚠️ This value might have side effects -- *35* module["unstable_now"]() - ⚠️ nested operation -- *36* (???*37* ? (???*41* | ???*42*) : ???*43*) - ⚠️ nested operation -- *37* (???*38* !== (???*39* | ???*40*)) - ⚠️ nested operation -- *38* unsupported expression + +0 -> 7082 call = (...) => ???*0*(3, null, null, (???*1* | 1 | ???*2* | 0)) +- *0* unknown new expression ⚠️ This value might have side effects -- *39* unsupported expression +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* unsupported assign operation ⚠️ This value might have side effects -- *40* module["unstable_now"]() - ⚠️ nested operation -- *41* unsupported expression + +0 -> 7086 call = (...) => undefined((???*0* | ???*1*)) +- *0* arguments[5] + ⚠️ function calls are not analysed yet +- *1* unknown new expression ⚠️ This value might have side effects -- *42* module["unstable_now"]() - ⚠️ nested operation -- *43* unsupported expression + +0 -> 7087 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 6299 call = (...) => undefined( - ???*0*, - (???*1* | ???*3* | ???*4*), - ( - | 1 - | ???*5* - | ???*6* - | ???*7* - | ???*9* - | ???*10* - | 0 - | ???*11* - | 4 - | ((???*12* | ???*14*) ? ???*15* : 4) - | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) - | ???*27* - | ???*28* - | (???*30* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ) -) -- *0* max number of linking steps reached +0 -> 7089 free var = FreeVar(arguments) + +0 -> 7091 free var = FreeVar(arguments) + +0 -> 7092 conditional = (???*0* | (???*1* !== ???*2*)) +- *0* unsupported expression ⚠️ This value might have side effects -- *1* ???*2*["current"] +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* ???*3*[3] ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* FreeVar(undefined) + ⚠️ This value might have side effects +- *3* FreeVar(arguments) ⚠️ unknown global ⚠️ This value might have side effects -- *4* unknown mutation + +7092 -> 7094 free var = FreeVar(arguments) + +0 -> 7095 conditional = (null == ???*0*) +- *0* ((???*1* | ???*2*) ? ???*6* : null) + ⚠️ nested operation +- *1* unsupported expression ⚠️ This value might have side effects -- *5* unsupported expression +- *2* (???*3* !== ???*4*) + ⚠️ nested operation +- *3* unsupported expression ⚠️ This value might have side effects -- *6* Ck - ⚠️ sequence with side effects +- *4* ???*5*[3] + ⚠️ unknown object ⚠️ This value might have side effects -- *7* ???*8*["current"] +- *5* FreeVar(arguments) + ⚠️ unknown global + ⚠️ This value might have side effects +- *6* ???*7*[3] ⚠️ unknown object -- *8* arguments[1] - ⚠️ function calls are not analysed yet -- *9* FreeVar(undefined) + ⚠️ This value might have side effects +- *7* FreeVar(arguments) ⚠️ unknown global ⚠️ This value might have side effects -- *10* unknown mutation + +0 -> 7096 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *11* C - ⚠️ circular variable reference -- *12* (0 !== ???*13*) - ⚠️ nested operation -- *13* C + +0 -> 7097 conditional = !((???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["_reactInternals"] + ⚠️ unknown object +- *2* a ⚠️ circular variable reference -- *14* unsupported expression + +7097 -> 7098 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *15* C + +7097 -> 7100 call = (...) => ((3 === b["tag"]) ? c : null)((???*0* | ???*1*)) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["_reactInternals"] + ⚠️ unknown object +- *2* a ⚠️ circular variable reference -- *16* unsupported expression - ⚠️ This value might have side effects -- *17* (???*18* ? ???*19* : 1) + +7097 -> 7102 conditional = ((???*0* !== (???*8* | ???*9*)) | (1 !== ???*11*)) +- *0* (???*1* ? (???*4* | ???*5* | ???*7*) : null) ⚠️ nested operation -- *18* unsupported expression - ⚠️ This value might have side effects -- *19* (???*20* ? ???*21* : 4) +- *1* (3 === ???*2*) ⚠️ nested operation -- *20* unsupported expression +- *2* ???*3*["tag"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* arguments[0] + ⚠️ function calls are not analysed yet +- *5* ???*6*["_reactInternals"] + ⚠️ unknown object +- *6* a + ⚠️ circular variable reference +- *7* a + ⚠️ circular variable reference +- *8* arguments[0] + ⚠️ function calls are not analysed yet +- *9* ???*10*["_reactInternals"] + ⚠️ unknown object +- *10* a + ⚠️ circular variable reference +- *11* ???*12*["tag"] + ⚠️ unknown object +- *12* arguments[0] + ⚠️ function calls are not analysed yet + +7102 -> 7103 free var = FreeVar(Error) + +7102 -> 7104 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(170) + +7102 -> 7105 call = ???*0*( + `Minified React error #${170}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) + ⚠️ unknown global ⚠️ This value might have side effects -- *21* (???*22* ? 16 : 536870912) - ⚠️ nested operation -- *22* (0 !== ???*23*) +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${170}` ⚠️ nested operation -- *23* unsupported expression + +7097 -> 7110 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +- *0* unsupported expression ⚠️ This value might have side effects -- *24* arguments[0] - ⚠️ function calls are not analysed yet -- *25* ???*26*["value"] +- *1* ???*2*["type"] ⚠️ unknown object -- *26* arguments[1] - ⚠️ function calls are not analysed yet -- *27* arguments[0] +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *28* ???*29*["event"] + +7097 -> 7111 conditional = ((null !== ???*0*) | (???*2* !== ???*3*)) +- *0* ???*1*["type"] ⚠️ unknown object +- *1* arguments[0] + ⚠️ function calls are not analysed yet +- *2* unsupported expression ⚠️ This value might have side effects -- *29* FreeVar(window) +- *3* ???*4*["type"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet + +0 -> 7115 free var = FreeVar(Error) + +0 -> 7116 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(171) + +0 -> 7117 call = ???*0*( + `Minified React error #${171}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) +- *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *30* (???*31* === ???*32*) +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${171}` ⚠️ nested operation -- *31* unsupported expression - ⚠️ This value might have side effects -- *32* a - ⚠️ circular variable reference -0 -> 6310 conditional = ((null !== (???*0* | ???*1*)) | (null !== ???*3*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["memoizedState"] +0 -> 7119 conditional = (1 === ???*0*) +- *0* ???*1*["tag"] ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* ???*4*["dehydrated"] +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +7119 -> 7121 call = (...) => ((null !== a) && (???*0* !== a))(???*1*) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* ???*2*["type"] ⚠️ unknown object -- *4* arguments[0] +- *2* arguments[0] ⚠️ function calls are not analysed yet -6310 -> 6313 conditional = ((0 !== ???*0*) | ???*2*) -- *0* ???*1*["retryLane"] +7119 -> 7122 conditional = ((null !== ???*0*) | (???*2* !== ???*3*)) +- *0* ???*1*["type"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet - *2* unsupported expression ⚠️ This value might have side effects +- *3* ???*4*["type"] + ⚠️ unknown object +- *4* arguments[0] + ⚠️ function calls are not analysed yet -0 -> 6314 call = (...) => undefined((???*0* | ???*1*), ???*3*) +7122 -> 7123 call = (...) => (c | A({}, c, d))((???*0* | ???*1*), ???*3*, (???*5* | ???*6*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["alternate"] +- *1* ???*2*["_reactInternals"] ⚠️ unknown object - *2* a ⚠️ circular variable reference -- *3* arguments[1] +- *3* ???*4*["type"] + ⚠️ unknown object +- *4* arguments[0] ⚠️ function calls are not analysed yet +- *5* arguments[0] + ⚠️ function calls are not analysed yet +- *6* ???*7*["_reactInternals"] + ⚠️ unknown object +- *7* a + ⚠️ circular variable reference -0 -> 6316 call = (...) => undefined((???*0* | ???*1*), ???*3*) -- *0* arguments[0] +7122 -> 7124 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 7125 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 7126 call = (...) => a( + (???*0* | ???*1* | ???*3*), + (???*5* | (???*6* ? ???*8* : ???*9*)), + true, + (???*17* | ???*18* | ???*20*), + ( + | ???*21* + | 1 + | ???*22* + | ???*23* + | ???*24* + | ???*26* + | 0 + | ???*28* + | 4 + | ((???*29* | ???*31*) ? ???*32* : 4) + | (???*33* ? 16 : (???*34* | null | ???*41* | ???*42*)) + | (???*44* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + ( + | ???*47* + | { + "eventTime": (???*48* | (???*49* ? ???*51* : ???*52*)), + "lane": ( + | ???*60* + | 1 + | ???*61* + | ???*62* + | ???*63* + | ???*65* + | 0 + | ???*67* + | 4 + | ((???*68* | ???*70*) ? ???*71* : 4) + | (???*72* ? 16 : (???*73* | null | ???*80* | ???*81*)) + | (???*83* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + "tag": 0, + "payload": null, + "callback": null, + "next": null + } + ), + ???*86*, + ???*87*, + ???*88* +) +- *0* arguments[2] ⚠️ function calls are not analysed yet -- *1* ???*2*["alternate"] +- *1* ???*2*["current"] ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* arguments[1] +- *2* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 6317 free var = FreeVar(reportError) - -0 -> 6318 conditional = ("function" === ???*0*) -- *0* typeof(???*1*) - ⚠️ nested operation -- *1* FreeVar(reportError) - ⚠️ unknown global +- *3* ???*4*["current"] + ⚠️ unknown object ⚠️ This value might have side effects - -6318 -> 6319 free var = FreeVar(reportError) - -6318 -> 6321 free var = FreeVar(console) - -6318 -> 6322 member call = ???*0*["error"](???*1*) -- *0* FreeVar(console) - ⚠️ unknown global +- *4* unknown new expression ⚠️ This value might have side effects -- *1* arguments[0] +- *5* arguments[3] ⚠️ function calls are not analysed yet - -0 -> 6329 conditional = (null === ???*0*) -- *0* ???*1*["_internalRoot"] - ⚠️ unknown object +- *6* (0 !== ???*7*) + ⚠️ nested operation +- *7* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression +- *8* module["unstable_now"]() + ⚠️ nested operation +- *9* (???*10* ? (???*14* | ???*15*) : ???*16*) + ⚠️ nested operation +- *10* (???*11* !== (???*12* | ???*13*)) + ⚠️ nested operation +- *11* unsupported expression ⚠️ This value might have side effects - -6329 -> 6330 free var = FreeVar(Error) - -6329 -> 6331 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(409) - -6329 -> 6332 call = ???*0*( - `Minified React error #${409}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *12* unsupported expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${409}` +- *13* module["unstable_now"]() ⚠️ nested operation - -0 -> 6333 call = (...) => g(???*0*, ???*1*, null, null) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* ???*2*["_internalRoot"] - ⚠️ unknown object +- *14* unsupported expression ⚠️ This value might have side effects -- *2* unsupported expression +- *15* module["unstable_now"]() + ⚠️ nested operation +- *16* unsupported expression ⚠️ This value might have side effects - -0 -> 6339 conditional = (null !== ???*0*) -- *0* ???*1*["_internalRoot"] +- *17* arguments[0] + ⚠️ function calls are not analysed yet +- *18* ???*19*["current"] ⚠️ unknown object +- *19* a + ⚠️ circular variable reference +- *20* unknown new expression ⚠️ This value might have side effects -- *1* unsupported expression +- *21* arguments[4] + ⚠️ function calls are not analysed yet +- *22* unsupported expression ⚠️ This value might have side effects - -6339 -> 6342 call = (...) => (undefined | a())((...) => undefined) - -6342 -> 6343 call = (...) => g(null, ???*0*, null, null) -- *0* ???*1*["_internalRoot"] +- *23* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *24* ???*25*["current"] + ⚠️ unknown object +- *25* arguments[0] + ⚠️ function calls are not analysed yet +- *26* ???*27*["current"] ⚠️ unknown object ⚠️ This value might have side effects -- *1* unsupported expression +- *27* unknown new expression ⚠️ This value might have side effects - -0 -> 6348 conditional = ( - | ???*0* - | { - "blockedOn": null, - "target": ???*1*, - "priority": ( - | ???*2*() - | 0 - | 1 - | ???*3* - | 4 - | ((???*4* | ???*6*) ? ???*7* : 4) - | (???*8* ? 16 : (???*9* | null | ???*16* | ???*17*)) - | ???*19* - ) - } -) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* a - ⚠️ circular variable reference -- *2* Hc - ⚠️ pattern without value -- *3* C +- *28* C ⚠️ circular variable reference -- *4* (0 !== ???*5*) +- *29* (0 !== ???*30*) ⚠️ nested operation -- *5* C +- *30* C ⚠️ circular variable reference -- *6* unsupported expression +- *31* unsupported expression ⚠️ This value might have side effects -- *7* C +- *32* C ⚠️ circular variable reference -- *8* unsupported expression +- *33* unsupported expression ⚠️ This value might have side effects -- *9* (???*10* ? ???*11* : 1) +- *34* (???*35* ? ???*36* : 1) ⚠️ nested operation -- *10* unsupported expression +- *35* unsupported expression ⚠️ This value might have side effects -- *11* (???*12* ? ???*13* : 4) +- *36* (???*37* ? ???*38* : 4) ⚠️ nested operation -- *12* unsupported expression +- *37* unsupported expression ⚠️ This value might have side effects -- *13* (???*14* ? 16 : 536870912) +- *38* (???*39* ? 16 : 536870912) ⚠️ nested operation -- *14* (0 !== ???*15*) +- *39* (0 !== ???*40*) ⚠️ nested operation -- *15* unsupported expression +- *40* unsupported expression ⚠️ This value might have side effects -- *16* arguments[0] +- *41* arguments[0] ⚠️ function calls are not analysed yet -- *17* ???*18*["value"] +- *42* ???*43*["value"] ⚠️ unknown object -- *18* arguments[1] - ⚠️ function calls are not analysed yet -- *19* arguments[0] - ⚠️ function calls are not analysed yet - -6348 -> 6349 call = (???*0* | (...) => C)() -- *0* Hc - ⚠️ pattern without value - -6348 -> 6354 member call = []["splice"]( - (0 | ???*0*), - 0, - ( - | ???*1* - | { - "blockedOn": null, - "target": ???*2*, - "priority": ( - | ???*3*() - | 0 - | 1 - | ???*4* - | 4 - | ((???*5* | ???*7*) ? ???*8* : 4) - | (???*9* ? 16 : (???*10* | null | ???*17* | ???*18*)) - | ???*20* - ) - } - ) -) -- *0* updated with update expression - ⚠️ This value might have side effects -- *1* arguments[0] +- *43* arguments[1] ⚠️ function calls are not analysed yet -- *2* a - ⚠️ circular variable reference -- *3* Hc - ⚠️ pattern without value -- *4* C - ⚠️ circular variable reference -- *5* (0 !== ???*6*) +- *44* (???*45* === ???*46*) ⚠️ nested operation -- *6* C - ⚠️ circular variable reference -- *7* unsupported expression +- *45* unsupported expression ⚠️ This value might have side effects -- *8* C +- *46* a ⚠️ circular variable reference -- *9* unsupported expression - ⚠️ This value might have side effects -- *10* (???*11* ? ???*12* : 1) +- *47* arguments[5] + ⚠️ function calls are not analysed yet +- *48* arguments[3] + ⚠️ function calls are not analysed yet +- *49* (0 !== ???*50*) ⚠️ nested operation -- *11* unsupported expression +- *50* unsupported expression ⚠️ This value might have side effects -- *12* (???*13* ? ???*14* : 4) +- *51* module["unstable_now"]() ⚠️ nested operation -- *13* unsupported expression +- *52* (???*53* ? (???*57* | ???*58*) : ???*59*) + ⚠️ nested operation +- *53* (???*54* !== (???*55* | ???*56*)) + ⚠️ nested operation +- *54* unsupported expression ⚠️ This value might have side effects -- *14* (???*15* ? 16 : 536870912) +- *55* unsupported expression + ⚠️ This value might have side effects +- *56* module["unstable_now"]() ⚠️ nested operation -- *15* (0 !== ???*16*) +- *57* unsupported expression + ⚠️ This value might have side effects +- *58* module["unstable_now"]() ⚠️ nested operation -- *16* unsupported expression +- *59* unsupported expression ⚠️ This value might have side effects -- *17* arguments[0] +- *60* arguments[4] ⚠️ function calls are not analysed yet -- *18* ???*19*["value"] +- *61* unsupported expression + ⚠️ This value might have side effects +- *62* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *63* ???*64*["current"] ⚠️ unknown object -- *19* arguments[1] - ⚠️ function calls are not analysed yet -- *20* arguments[0] - ⚠️ function calls are not analysed yet - -6348 -> 6355 call = (...) => (undefined | FreeVar(undefined))( - ( - | ???*0* - | { - "blockedOn": null, - "target": ???*1*, - "priority": ( - | ???*2*() - | 0 - | 1 - | ???*3* - | 4 - | ((???*4* | ???*6*) ? ???*7* : 4) - | (???*8* ? 16 : (???*9* | null | ???*16* | ???*17*)) - | ???*19* - ) - } - ) -) -- *0* arguments[0] +- *64* arguments[0] ⚠️ function calls are not analysed yet -- *1* a - ⚠️ circular variable reference -- *2* Hc - ⚠️ pattern without value -- *3* C +- *65* ???*66*["current"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *66* unknown new expression + ⚠️ This value might have side effects +- *67* C ⚠️ circular variable reference -- *4* (0 !== ???*5*) +- *68* (0 !== ???*69*) ⚠️ nested operation -- *5* C +- *69* C ⚠️ circular variable reference -- *6* unsupported expression +- *70* unsupported expression ⚠️ This value might have side effects -- *7* C +- *71* C ⚠️ circular variable reference -- *8* unsupported expression +- *72* unsupported expression ⚠️ This value might have side effects -- *9* (???*10* ? ???*11* : 1) +- *73* (???*74* ? ???*75* : 1) ⚠️ nested operation -- *10* unsupported expression +- *74* unsupported expression ⚠️ This value might have side effects -- *11* (???*12* ? ???*13* : 4) +- *75* (???*76* ? ???*77* : 4) ⚠️ nested operation -- *12* unsupported expression +- *76* unsupported expression ⚠️ This value might have side effects -- *13* (???*14* ? 16 : 536870912) +- *77* (???*78* ? 16 : 536870912) ⚠️ nested operation -- *14* (0 !== ???*15*) +- *78* (0 !== ???*79*) ⚠️ nested operation -- *15* unsupported expression +- *79* unsupported expression ⚠️ This value might have side effects -- *16* arguments[0] +- *80* arguments[0] ⚠️ function calls are not analysed yet -- *17* ???*18*["value"] +- *81* ???*82*["value"] ⚠️ unknown object -- *18* arguments[1] +- *82* arguments[1] ⚠️ function calls are not analysed yet -- *19* arguments[0] +- *83* (???*84* === ???*85*) + ⚠️ nested operation +- *84* unsupported expression + ⚠️ This value might have side effects +- *85* a + ⚠️ circular variable reference +- *86* arguments[6] ⚠️ function calls are not analysed yet - -0 -> 6364 conditional = (???*0* | ???*1*) -- *0* arguments[4] +- *87* arguments[7] ⚠️ function calls are not analysed yet -- *1* ???*2*["lastChild"] - ⚠️ unknown object -- *2* arguments[0] +- *88* arguments[8] ⚠️ function calls are not analysed yet -6364 -> 6365 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | (...) => undefined)) - ⚠️ nested operation -- *1* arguments[3] - ⚠️ function calls are not analysed yet +0 -> 7128 call = (...) => (Vf | bg(a, c, b) | b)(null) -6365 -> 6366 call = (...) => (undefined | null | a["child"]["stateNode"])((???*0* | ???*1* | ???*3*)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* ???*2*["current"] - ⚠️ unknown object -- *2* a - ⚠️ circular variable reference -- *3* unknown new expression +0 -> 7130 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +- *0* unsupported expression ⚠️ This value might have side effects - -6365 -> 6368 member call = (???*0* | (...) => undefined)["call"](???*1*) -- *0* arguments[3] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* unsupported expression ⚠️ This value might have side effects -6364 -> 6369 call = (...) => a(???*0*, (???*1* | (...) => undefined), ???*2*, 0, null, false, false, "", (...) => undefined) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* arguments[3] - ⚠️ function calls are not analysed yet -- *2* arguments[0] - ⚠️ function calls are not analysed yet - -6364 -> 6374 conditional = (8 === ???*0*) -- *0* ???*1*["nodeType"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -6364 -> 6376 call = (...) => undefined((???*0* ? ???*3* : ???*5*)) -- *0* (8 === ???*1*) - ⚠️ nested operation -- *1* ???*2*["nodeType"] - ⚠️ unknown object -- *2* arguments[0] +0 -> 7131 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*3* | ???*5*)) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *2* arguments[2] ⚠️ function calls are not analysed yet -- *3* ???*4*["parentNode"] +- *3* ???*4*["current"] ⚠️ unknown object - *4* arguments[0] ⚠️ function calls are not analysed yet -- *5* arguments[0] - ⚠️ function calls are not analysed yet - -6364 -> 6377 call = (...) => (undefined | a())() - -0 -> 6380 member call = ???*0*["removeChild"]((???*1* | ???*2*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[4] - ⚠️ function calls are not analysed yet -- *2* ???*3*["lastChild"] +- *5* ???*6*["current"] ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6381 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | (...) => undefined)) - ⚠️ nested operation -- *1* arguments[3] - ⚠️ function calls are not analysed yet - -6381 -> 6382 call = (...) => (undefined | null | a["child"]["stateNode"])((???*0* | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* unknown new expression + ⚠️ This value might have side effects +- *6* unknown new expression ⚠️ This value might have side effects -6381 -> 6384 member call = (???*0* | (...) => undefined)["call"]((undefined | null | ???*1* | ???*4*)) +0 -> 7132 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( + (???*0* | (???*1* ? ???*3* : ???*4*)), + ( + | ???*12* + | 1 + | ???*13* + | ???*14* + | ???*15* + | ???*17* + | 0 + | ???*19* + | 4 + | ((???*20* | ???*22*) ? ???*23* : 4) + | (???*24* ? 16 : (???*25* | null | ???*32* | ???*33*)) + | (???*35* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ) +) - *0* arguments[3] ⚠️ function calls are not analysed yet -- *1* ???*2*["stateNode"] - ⚠️ unknown object -- *2* ???*3*["child"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object +- *1* (0 !== ???*2*) + ⚠️ nested operation +- *2* unsupported expression ⚠️ This value might have side effects -- *5* ???*6*["child"] - ⚠️ unknown object +- *3* module["unstable_now"]() + ⚠️ nested operation +- *4* (???*5* ? (???*9* | ???*10*) : ???*11*) + ⚠️ nested operation +- *5* (???*6* !== (???*7* | ???*8*)) + ⚠️ nested operation +- *6* unsupported expression ⚠️ This value might have side effects -- *6* unknown new expression +- *7* unsupported expression ⚠️ This value might have side effects - -0 -> 6385 call = (...) => a(???*0*, 0, false, null, null, false, false, "", (...) => undefined) -- *0* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6390 conditional = (8 === ???*0*) -- *0* ???*1*["nodeType"] - ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6392 call = (...) => undefined((???*0* ? ???*3* : ???*5*)) -- *0* (8 === ???*1*) +- *8* module["unstable_now"]() ⚠️ nested operation -- *1* ???*2*["nodeType"] - ⚠️ unknown object -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* ???*4*["parentNode"] - ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* arguments[0] - ⚠️ function calls are not analysed yet - -0 -> 6393 call = (...) => (undefined | a())((...) => undefined) - -6393 -> 6394 call = (...) => g(???*0*, (???*1* | ???*2*), ???*3*, (???*4* | (...) => undefined)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* arguments[0] - ⚠️ function calls are not analysed yet -- *2* unknown new expression +- *9* unsupported expression ⚠️ This value might have side effects -- *3* arguments[2] - ⚠️ function calls are not analysed yet -- *4* arguments[3] +- *10* module["unstable_now"]() + ⚠️ nested operation +- *11* unsupported expression + ⚠️ This value might have side effects +- *12* arguments[4] ⚠️ function calls are not analysed yet - -0 -> 6396 conditional = ???*0* -- *0* ???*1*["_reactRootContainer"] +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *15* ???*16*["current"] ⚠️ unknown object -- *1* arguments[2] +- *16* arguments[0] ⚠️ function calls are not analysed yet - -6396 -> 6397 conditional = ("function" === ???*0*) -- *0* typeof((???*1* | (...) => undefined)) +- *17* ???*18*["current"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *18* unknown new expression + ⚠️ This value might have side effects +- *19* C + ⚠️ circular variable reference +- *20* (0 !== ???*21*) ⚠️ nested operation -- *1* arguments[4] - ⚠️ function calls are not analysed yet - -6397 -> 6398 call = (...) => (undefined | null | a["child"]["stateNode"])(???*0*) -- *0* max number of linking steps reached +- *21* C + ⚠️ circular variable reference +- *22* unsupported expression ⚠️ This value might have side effects - -6397 -> 6400 member call = (???*0* | (...) => undefined)["call"](???*1*) -- *0* arguments[4] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +- *23* C + ⚠️ circular variable reference +- *24* unsupported expression ⚠️ This value might have side effects - -6396 -> 6401 call = (...) => g(???*0*, ???*1*, ???*2*, (???*3* | (...) => undefined)) -- *0* arguments[1] - ⚠️ function calls are not analysed yet -- *1* max number of linking steps reached +- *25* (???*26* ? ???*27* : 1) + ⚠️ nested operation +- *26* unsupported expression ⚠️ This value might have side effects -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[4] - ⚠️ function calls are not analysed yet - -6396 -> 6402 call = (...) => (g | k)(???*0*, ???*1*, ???*2*, (???*3* | (...) => undefined), ???*4*) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* arguments[4] - ⚠️ function calls are not analysed yet -- *4* arguments[3] - ⚠️ function calls are not analysed yet - -0 -> 6403 call = (...) => (undefined | null | a["child"]["stateNode"])(???*0*) -- *0* max number of linking steps reached +- *27* (???*28* ? ???*29* : 4) + ⚠️ nested operation +- *28* unsupported expression + ⚠️ This value might have side effects +- *29* (???*30* ? 16 : 536870912) + ⚠️ nested operation +- *30* (0 !== ???*31*) + ⚠️ nested operation +- *31* unsupported expression ⚠️ This value might have side effects - -0 -> 6409 conditional = ???*0* -- *0* ???*1*["isDehydrated"] - ⚠️ unknown object -- *1* ???*2*["memoizedState"] - ⚠️ unknown object -- *2* ???*3*["current"] - ⚠️ unknown object -- *3* ???*4*["stateNode"] +- *32* arguments[0] + ⚠️ function calls are not analysed yet +- *33* ???*34*["value"] ⚠️ unknown object -- *4* arguments[0] +- *34* arguments[1] ⚠️ function calls are not analysed yet +- *35* (???*36* === ???*37*) + ⚠️ nested operation +- *36* unsupported expression + ⚠️ This value might have side effects +- *37* a + ⚠️ circular variable reference -6409 -> 6411 call = (...) => (undefined | 1 | 2 | 4 | 8 | 16 | 32 | ???*0* | 134217728 | 268435456 | 536870912 | 1073741824 | a)(???*1*) +0 -> 7134 conditional = ((???*0* !== ???*1*) | (null !== ???*2*)) - *0* unsupported expression ⚠️ This value might have side effects -- *1* ???*2*["pendingLanes"] - ⚠️ unknown object -- *2* ???*3*["stateNode"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet - -6409 -> 6412 call = (...) => undefined(???*0*, ???*2*) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *2* unsupported expression - ⚠️ This value might have side effects - -6409 -> 6413 call = module["unstable_now"]() - -6409 -> 6414 call = (...) => undefined(???*0*, module["unstable_now"]()) -- *0* ???*1*["stateNode"] - ⚠️ unknown object -- *1* arguments[0] +- *2* arguments[1] ⚠️ function calls are not analysed yet -6409 -> 6415 call = module["unstable_now"]() - -6409 -> 6416 call = (...) => null() - -0 -> 6417 call = (...) => (undefined | a())((...) => undefined) - -6417 -> 6418 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, 1) -- *0* arguments[0] +0 -> 7135 call = (...) => (null | Zg(a, c))( + (???*0* | ???*1* | ???*3*), + ( + | ???*5* + | { + "eventTime": (???*6* | (???*7* ? ???*9* : ???*10*)), + "lane": ( + | ???*18* + | 1 + | ???*19* + | ???*20* + | ???*21* + | ???*23* + | 0 + | ???*25* + | 4 + | ((???*26* | ???*28*) ? ???*29* : 4) + | (???*30* ? 16 : (???*31* | null | ???*38* | ???*39*)) + | (???*41* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + "tag": 0, + "payload": null, + "callback": null, + "next": null + } + ), + ( + | ???*44* + | 1 + | ???*45* + | ???*46* + | ???*47* + | ???*49* + | 0 + | ???*51* + | 4 + | ((???*52* | ???*54*) ? ???*55* : 4) + | (???*56* ? 16 : (???*57* | null | ???*64* | ???*65*)) + | (???*67* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ) +) +- *0* arguments[2] ⚠️ function calls are not analysed yet - -6417 -> 6419 conditional = (null !== ???*0*) -- *0* (???*1* ? ???*5* : null) - ⚠️ nested operation -- *1* (3 === ???*2*) - ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* ???*4*["alternate"] +- *1* ???*2*["current"] ⚠️ unknown object -- *4* arguments[0] +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *5* ???*6*["stateNode"] - ⚠️ unknown object -- *6* ???*7*["alternate"] +- *3* ???*4*["current"] ⚠️ unknown object -- *7* arguments[0] - ⚠️ function calls are not analysed yet - -6419 -> 6420 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* unsupported expression ⚠️ This value might have side effects -- *2* unsupported expression +- *4* unknown new expression ⚠️ This value might have side effects - -6419 -> 6421 call = (...) => undefined((???*0* ? ???*4* : null), ???*7*, 1, (???*8* ? ???*10* : ???*11*)) -- *0* (3 === ???*1*) - ⚠️ nested operation -- *1* ???*2*["tag"] - ⚠️ unknown object -- *2* ???*3*["alternate"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* ???*6*["alternate"] - ⚠️ unknown object -- *6* arguments[0] +- *5* arguments[5] ⚠️ function calls are not analysed yet -- *7* arguments[0] +- *6* arguments[3] ⚠️ function calls are not analysed yet -- *8* (0 !== ???*9*) +- *7* (0 !== ???*8*) ⚠️ nested operation -- *9* unsupported expression +- *8* unsupported expression ⚠️ This value might have side effects -- *10* module["unstable_now"]() +- *9* module["unstable_now"]() ⚠️ nested operation -- *11* (???*12* ? (???*16* | ???*17*) : ???*18*) +- *10* (???*11* ? (???*15* | ???*16*) : ???*17*) ⚠️ nested operation -- *12* (???*13* !== (???*14* | ???*15*)) +- *11* (???*12* !== (???*13* | ???*14*)) ⚠️ nested operation -- *13* unsupported expression +- *12* unsupported expression ⚠️ This value might have side effects -- *14* unsupported expression +- *13* unsupported expression ⚠️ This value might have side effects -- *15* module["unstable_now"]() +- *14* module["unstable_now"]() ⚠️ nested operation -- *16* unsupported expression +- *15* unsupported expression ⚠️ This value might have side effects -- *17* module["unstable_now"]() +- *16* module["unstable_now"]() ⚠️ nested operation -- *18* unsupported expression +- *17* unsupported expression ⚠️ This value might have side effects - -0 -> 6422 call = (...) => undefined(???*0*, 1) -- *0* arguments[0] +- *18* arguments[4] ⚠️ function calls are not analysed yet - -0 -> 6424 conditional = (13 === ???*0*) -- *0* ???*1*["tag"] +- *19* unsupported expression + ⚠️ This value might have side effects +- *20* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *21* ???*22*["current"] ⚠️ unknown object -- *1* arguments[0] - ⚠️ function calls are not analysed yet - -6424 -> 6425 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)(???*0*, 134217728) -- *0* arguments[0] +- *22* arguments[0] ⚠️ function calls are not analysed yet - -6424 -> 6426 conditional = (null !== ???*0*) -- *0* (???*1* ? ???*5* : null) +- *23* ???*24*["current"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *24* unknown new expression + ⚠️ This value might have side effects +- *25* C + ⚠️ circular variable reference +- *26* (0 !== ???*27*) ⚠️ nested operation -- *1* (3 === ???*2*) +- *27* C + ⚠️ circular variable reference +- *28* unsupported expression + ⚠️ This value might have side effects +- *29* C + ⚠️ circular variable reference +- *30* unsupported expression + ⚠️ This value might have side effects +- *31* (???*32* ? ???*33* : 1) ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* ???*4*["alternate"] - ⚠️ unknown object -- *4* arguments[0] +- *32* unsupported expression + ⚠️ This value might have side effects +- *33* (???*34* ? ???*35* : 4) + ⚠️ nested operation +- *34* unsupported expression + ⚠️ This value might have side effects +- *35* (???*36* ? 16 : 536870912) + ⚠️ nested operation +- *36* (0 !== ???*37*) + ⚠️ nested operation +- *37* unsupported expression + ⚠️ This value might have side effects +- *38* arguments[0] ⚠️ function calls are not analysed yet -- *5* ???*6*["stateNode"] - ⚠️ unknown object -- *6* ???*7*["alternate"] +- *39* ???*40*["value"] ⚠️ unknown object -- *7* arguments[0] +- *40* arguments[1] ⚠️ function calls are not analysed yet - -6426 -> 6427 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() -- *0* unsupported expression +- *41* (???*42* === ???*43*) + ⚠️ nested operation +- *42* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression +- *43* a + ⚠️ circular variable reference +- *44* arguments[4] + ⚠️ function calls are not analysed yet +- *45* unsupported expression ⚠️ This value might have side effects -- *2* unsupported expression +- *46* Ck + ⚠️ sequence with side effects ⚠️ This value might have side effects - -6426 -> 6428 call = (...) => undefined((???*0* ? ???*4* : null), ???*7*, 134217728, (???*8* ? ???*10* : ???*11*)) -- *0* (3 === ???*1*) - ⚠️ nested operation -- *1* ???*2*["tag"] - ⚠️ unknown object -- *2* ???*3*["alternate"] +- *47* ???*48*["current"] ⚠️ unknown object -- *3* arguments[0] +- *48* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* ???*6*["alternate"] +- *49* ???*50*["current"] ⚠️ unknown object -- *6* arguments[0] - ⚠️ function calls are not analysed yet -- *7* arguments[0] - ⚠️ function calls are not analysed yet -- *8* (0 !== ???*9*) - ⚠️ nested operation -- *9* unsupported expression ⚠️ This value might have side effects -- *10* module["unstable_now"]() - ⚠️ nested operation -- *11* (???*12* ? (???*16* | ???*17*) : ???*18*) - ⚠️ nested operation -- *12* (???*13* !== (???*14* | ???*15*)) +- *50* unknown new expression + ⚠️ This value might have side effects +- *51* C + ⚠️ circular variable reference +- *52* (0 !== ???*53*) ⚠️ nested operation -- *13* unsupported expression +- *53* C + ⚠️ circular variable reference +- *54* unsupported expression ⚠️ This value might have side effects -- *14* unsupported expression +- *55* C + ⚠️ circular variable reference +- *56* unsupported expression ⚠️ This value might have side effects -- *15* module["unstable_now"]() +- *57* (???*58* ? ???*59* : 1) ⚠️ nested operation -- *16* unsupported expression +- *58* unsupported expression ⚠️ This value might have side effects -- *17* module["unstable_now"]() +- *59* (???*60* ? ???*61* : 4) ⚠️ nested operation -- *18* unsupported expression +- *60* unsupported expression ⚠️ This value might have side effects - -6424 -> 6429 call = (...) => undefined(???*0*, 134217728) -- *0* arguments[0] +- *61* (???*62* ? 16 : 536870912) + ⚠️ nested operation +- *62* (0 !== ???*63*) + ⚠️ nested operation +- *63* unsupported expression + ⚠️ This value might have side effects +- *64* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 6431 conditional = (13 === ???*0*) -- *0* ???*1*["tag"] +- *65* ???*66*["value"] ⚠️ unknown object -- *1* arguments[0] +- *66* arguments[1] ⚠️ function calls are not analysed yet - -6431 -> 6432 call = (...) => (1 | ???*0* | ???*1* | a)(???*2*) -- *0* unsupported expression - ⚠️ This value might have side effects -- *1* Ck - ⚠️ sequence with side effects +- *67* (???*68* === ???*69*) + ⚠️ nested operation +- *68* unsupported expression ⚠️ This value might have side effects -- *2* arguments[0] - ⚠️ function calls are not analysed yet +- *69* a + ⚠️ circular variable reference -6431 -> 6433 call = (...) => ((3 === c["tag"]) ? c["stateNode"] : null)( - ???*0*, +0 -> 7138 call = (...) => undefined( + (???*0* | ???*1* | ???*3*), ( + | ???*4* | 1 - | ???*1* - | ???*2* - | ???*3* + | ???*5* + | ???*6* + | ???*7* + | ???*9* | 0 - | ???*4* + | ???*11* | 4 - | ((???*5* | ???*7*) ? ???*8* : 4) - | (???*9* ? 16 : (???*10* | null | ???*17* | ???*18*)) - | ???*20* - | (???*22* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ) + | ((???*12* | ???*14*) ? ???*15* : 4) + | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) + | (???*27* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + (???*30* | (???*31* ? ???*33* : ???*34*)) ) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* unsupported expression +- *1* ???*2*["current"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference +- *3* unknown new expression ⚠️ This value might have side effects -- *2* Ck +- *4* arguments[4] + ⚠️ function calls are not analysed yet +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* Ck ⚠️ sequence with side effects ⚠️ This value might have side effects -- *3* arguments[0] +- *7* ???*8*["current"] + ⚠️ unknown object +- *8* arguments[0] ⚠️ function calls are not analysed yet -- *4* C +- *9* ???*10*["current"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *10* unknown new expression + ⚠️ This value might have side effects +- *11* C ⚠️ circular variable reference -- *5* (0 !== ???*6*) +- *12* (0 !== ???*13*) ⚠️ nested operation -- *6* C +- *13* C ⚠️ circular variable reference -- *7* unsupported expression +- *14* unsupported expression ⚠️ This value might have side effects -- *8* C +- *15* C ⚠️ circular variable reference -- *9* unsupported expression +- *16* unsupported expression ⚠️ This value might have side effects -- *10* (???*11* ? ???*12* : 1) +- *17* (???*18* ? ???*19* : 1) ⚠️ nested operation -- *11* unsupported expression +- *18* unsupported expression ⚠️ This value might have side effects -- *12* (???*13* ? ???*14* : 4) +- *19* (???*20* ? ???*21* : 4) ⚠️ nested operation -- *13* unsupported expression +- *20* unsupported expression ⚠️ This value might have side effects -- *14* (???*15* ? 16 : 536870912) +- *21* (???*22* ? 16 : 536870912) ⚠️ nested operation -- *15* (0 !== ???*16*) +- *22* (0 !== ???*23*) ⚠️ nested operation -- *16* unsupported expression +- *23* unsupported expression ⚠️ This value might have side effects -- *17* arguments[0] +- *24* arguments[0] ⚠️ function calls are not analysed yet -- *18* ???*19*["value"] +- *25* ???*26*["value"] ⚠️ unknown object -- *19* arguments[1] +- *26* arguments[1] ⚠️ function calls are not analysed yet -- *20* ???*21*["event"] - ⚠️ unknown object +- *27* (???*28* === ???*29*) + ⚠️ nested operation +- *28* unsupported expression ⚠️ This value might have side effects -- *21* FreeVar(window) - ⚠️ unknown global +- *29* a + ⚠️ circular variable reference +- *30* arguments[3] + ⚠️ function calls are not analysed yet +- *31* (0 !== ???*32*) + ⚠️ nested operation +- *32* unsupported expression ⚠️ This value might have side effects -- *22* (???*23* === ???*24*) +- *33* module["unstable_now"]() ⚠️ nested operation -- *23* unsupported expression +- *34* (???*35* ? (???*39* | ???*40*) : ???*41*) + ⚠️ nested operation +- *35* (???*36* !== (???*37* | ???*38*)) + ⚠️ nested operation +- *36* unsupported expression ⚠️ This value might have side effects -- *24* a - ⚠️ circular variable reference - -6431 -> 6434 conditional = (null !== ???*0*) -- *0* (???*1* ? ???*5* : null) +- *37* unsupported expression + ⚠️ This value might have side effects +- *38* module["unstable_now"]() ⚠️ nested operation -- *1* (3 === ???*2*) +- *39* unsupported expression + ⚠️ This value might have side effects +- *40* module["unstable_now"]() ⚠️ nested operation -- *2* ???*3*["tag"] - ⚠️ unknown object -- *3* ???*4*["alternate"] - ⚠️ unknown object -- *4* arguments[0] +- *41* unsupported expression + ⚠️ This value might have side effects + +0 -> 7139 call = (...) => undefined((???*0* | ???*1* | ???*3*), (???*4* | (???*5* ? ???*7* : ???*8*))) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *5* ???*6*["stateNode"] - ⚠️ unknown object -- *6* ???*7*["alternate"] +- *1* ???*2*["current"] ⚠️ unknown object -- *7* arguments[0] +- *2* a + ⚠️ circular variable reference +- *3* unknown new expression + ⚠️ This value might have side effects +- *4* arguments[3] ⚠️ function calls are not analysed yet +- *5* (0 !== ???*6*) + ⚠️ nested operation +- *6* unsupported expression + ⚠️ This value might have side effects +- *7* module["unstable_now"]() + ⚠️ nested operation +- *8* (???*9* ? (???*13* | ???*14*) : ???*15*) + ⚠️ nested operation +- *9* (???*10* !== (???*11* | ???*12*)) + ⚠️ nested operation +- *10* unsupported expression + ⚠️ This value might have side effects +- *11* unsupported expression + ⚠️ This value might have side effects +- *12* module["unstable_now"]() + ⚠️ nested operation +- *13* unsupported expression + ⚠️ This value might have side effects +- *14* module["unstable_now"]() + ⚠️ nested operation +- *15* unsupported expression + ⚠️ This value might have side effects + +0 -> 7140 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -6434 -> 6435 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() +0 -> 7142 call = (...) => ((0 !== ???*0*) ? B() : ((???*1* !== Bk) ? Bk : ???*2*))() - *0* unsupported expression ⚠️ This value might have side effects - *1* unsupported expression @@ -36399,1338 +40083,1088 @@ ${(???*45* | ???*46* | ???*50* | "")}${(???*54* | ???*56*)}` - *2* unsupported expression ⚠️ This value might have side effects -6434 -> 6436 call = (...) => undefined( - (???*0* ? ???*4* : null), - ???*7*, +0 -> 7143 call = (...) => (1 | ???*0* | ???*1* | a)((???*2* | ???*4* | ???*5*)) +- *0* unsupported expression + ⚠️ This value might have side effects +- *1* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *2* ???*3*["current"] + ⚠️ unknown object +- *3* arguments[1] + ⚠️ function calls are not analysed yet +- *4* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *5* unknown mutation + ⚠️ This value might have side effects + +0 -> 7144 call = (...) => (Vf | bg(a, c, b) | b)((???*0* | {} | ???*1* | ???*2* | ???*4*)) +- *0* arguments[2] + ⚠️ function calls are not analysed yet +- *1* c + ⚠️ circular variable reference +- *2* ???*3*["_reactInternals"] + ⚠️ unknown object +- *3* a + ⚠️ circular variable reference +- *4* ???*5*({}, c, d) + ⚠️ unknown callee + ⚠️ This value might have side effects +- *5* ???*6*["assign"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *6* FreeVar(Object) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 7146 conditional = (null === (???*0* | ???*2* | ???*3*)) +- *0* ???*1*["context"] + ⚠️ unknown object +- *1* arguments[1] + ⚠️ function calls are not analysed yet +- *2* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *3* unknown mutation + ⚠️ This value might have side effects + +0 -> 7149 call = (...) => {"eventTime": a, "lane": b, "tag": 0, "payload": null, "callback": null, "next": null}( + (???*0* ? ???*2* : ???*3*), ( | 1 - | ???*8* - | ???*9* - | ???*10* - | 0 | ???*11* + | ???*12* + | ???*13* + | ???*15* + | ???*16* + | 0 + | ???*17* | 4 - | ((???*12* | ???*14*) ? ???*15* : 4) - | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) - | ???*27* - | (???*29* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) - ), - (???*32* ? ???*34* : ???*35*) + | ((???*18* | ???*20*) ? ???*21* : 4) + | (???*22* ? 16 : (???*23* | null | ???*30* | ???*31*)) + | ???*33* + | ???*34* + | (???*36* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ) ) -- *0* (3 === ???*1*) +- *0* (0 !== ???*1*) + ⚠️ nested operation +- *1* unsupported expression + ⚠️ This value might have side effects +- *2* module["unstable_now"]() + ⚠️ nested operation +- *3* (???*4* ? (???*8* | ???*9*) : ???*10*) + ⚠️ nested operation +- *4* (???*5* !== (???*6* | ???*7*)) + ⚠️ nested operation +- *5* unsupported expression + ⚠️ This value might have side effects +- *6* unsupported expression + ⚠️ This value might have side effects +- *7* module["unstable_now"]() ⚠️ nested operation -- *1* ???*2*["tag"] - ⚠️ unknown object -- *2* ???*3*["alternate"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet -- *4* ???*5*["stateNode"] - ⚠️ unknown object -- *5* ???*6*["alternate"] - ⚠️ unknown object -- *6* arguments[0] - ⚠️ function calls are not analysed yet -- *7* arguments[0] - ⚠️ function calls are not analysed yet - *8* unsupported expression ⚠️ This value might have side effects -- *9* Ck +- *9* module["unstable_now"]() + ⚠️ nested operation +- *10* unsupported expression + ⚠️ This value might have side effects +- *11* unsupported expression + ⚠️ This value might have side effects +- *12* Ck ⚠️ sequence with side effects ⚠️ This value might have side effects -- *10* arguments[0] +- *13* ???*14*["current"] + ⚠️ unknown object +- *14* arguments[1] ⚠️ function calls are not analysed yet -- *11* C +- *15* FreeVar(undefined) + ⚠️ unknown global + ⚠️ This value might have side effects +- *16* unknown mutation + ⚠️ This value might have side effects +- *17* C ⚠️ circular variable reference -- *12* (0 !== ???*13*) +- *18* (0 !== ???*19*) ⚠️ nested operation -- *13* C +- *19* C ⚠️ circular variable reference -- *14* unsupported expression +- *20* unsupported expression ⚠️ This value might have side effects -- *15* C +- *21* C ⚠️ circular variable reference -- *16* unsupported expression +- *22* unsupported expression ⚠️ This value might have side effects -- *17* (???*18* ? ???*19* : 1) +- *23* (???*24* ? ???*25* : 1) ⚠️ nested operation -- *18* unsupported expression +- *24* unsupported expression ⚠️ This value might have side effects -- *19* (???*20* ? ???*21* : 4) +- *25* (???*26* ? ???*27* : 4) ⚠️ nested operation -- *20* unsupported expression +- *26* unsupported expression ⚠️ This value might have side effects -- *21* (???*22* ? 16 : 536870912) +- *27* (???*28* ? 16 : 536870912) ⚠️ nested operation -- *22* (0 !== ???*23*) +- *28* (0 !== ???*29*) ⚠️ nested operation -- *23* unsupported expression +- *29* unsupported expression ⚠️ This value might have side effects -- *24* arguments[0] +- *30* arguments[0] ⚠️ function calls are not analysed yet -- *25* ???*26*["value"] +- *31* ???*32*["value"] ⚠️ unknown object -- *26* arguments[1] +- *32* arguments[1] ⚠️ function calls are not analysed yet -- *27* ???*28*["event"] +- *33* arguments[0] + ⚠️ function calls are not analysed yet +- *34* ???*35*["event"] ⚠️ unknown object ⚠️ This value might have side effects -- *28* FreeVar(window) +- *35* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *29* (???*30* === ???*31*) - ⚠️ nested operation -- *30* unsupported expression - ⚠️ This value might have side effects -- *31* a - ⚠️ circular variable reference -- *32* (0 !== ???*33*) - ⚠️ nested operation -- *33* unsupported expression - ⚠️ This value might have side effects -- *34* module["unstable_now"]() - ⚠️ nested operation -- *35* (???*36* ? (???*40* | ???*41*) : ???*42*) - ⚠️ nested operation -- *36* (???*37* !== (???*38* | ???*39*)) +- *36* (???*37* === ???*38*) ⚠️ nested operation - *37* unsupported expression ⚠️ This value might have side effects -- *38* unsupported expression +- *38* a + ⚠️ circular variable reference + +0 -> 7151 conditional = (???*0* === (???*1* | ???*2*)) +- *0* unsupported expression ⚠️ This value might have side effects -- *39* module["unstable_now"]() +- *1* arguments[3] + ⚠️ function calls are not analysed yet +- *2* (???*3* ? null : ???*6*) ⚠️ nested operation -- *40* unsupported expression - ⚠️ This value might have side effects -- *41* module["unstable_now"]() +- *3* (???*4* === ???*5*) ⚠️ nested operation -- *42* unsupported expression +- *4* unsupported expression ⚠️ This value might have side effects +- *5* d + ⚠️ circular variable reference +- *6* d + ⚠️ circular variable reference -6431 -> 6437 call = (...) => undefined( - ???*0*, +0 -> 7153 call = (...) => (null | Zg(a, c))( + (???*0* | ???*2* | ???*3*), + ( + | ???*4* + | { + "eventTime": (???*5* ? ???*7* : ???*8*), + "lane": ( + | 1 + | ???*16* + | ???*17* + | ???*18* + | 0 + | ???*20* + | 4 + | ((???*21* | ???*23*) ? ???*24* : 4) + | (???*25* ? 16 : (???*26* | null | ???*33* | ???*34*)) + | ???*36* + | ???*37* + | (???*39* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + "tag": 0, + "payload": null, + "callback": null, + "next": null + } + ), ( | 1 - | ???*1* - | ???*2* - | ???*3* + | ???*42* + | ???*43* + | ???*44* + | ???*46* + | ???*47* | 0 - | ???*4* + | ???*48* | 4 - | ((???*5* | ???*7*) ? ???*8* : 4) - | (???*9* ? 16 : (???*10* | null | ???*17* | ???*18*)) - | ???*20* - | (???*22* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + | ((???*49* | ???*51*) ? ???*52* : 4) + | (???*53* ? 16 : (???*54* | null | ???*61* | ???*62*)) + | ???*64* + | ???*65* + | (???*67* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) ) ) -- *0* arguments[0] +- *0* ???*1*["current"] + ⚠️ unknown object +- *1* arguments[1] ⚠️ function calls are not analysed yet -- *1* unsupported expression +- *2* FreeVar(undefined) + ⚠️ unknown global ⚠️ This value might have side effects -- *2* Ck - ⚠️ sequence with side effects +- *3* unknown mutation ⚠️ This value might have side effects -- *3* arguments[0] +- *4* arguments[1] ⚠️ function calls are not analysed yet -- *4* C - ⚠️ circular variable reference - *5* (0 !== ???*6*) ⚠️ nested operation -- *6* C - ⚠️ circular variable reference -- *7* unsupported expression - ⚠️ This value might have side effects -- *8* C - ⚠️ circular variable reference -- *9* unsupported expression +- *6* unsupported expression ⚠️ This value might have side effects -- *10* (???*11* ? ???*12* : 1) +- *7* module["unstable_now"]() + ⚠️ nested operation +- *8* (???*9* ? (???*13* | ???*14*) : ???*15*) + ⚠️ nested operation +- *9* (???*10* !== (???*11* | ???*12*)) ⚠️ nested operation +- *10* unsupported expression + ⚠️ This value might have side effects - *11* unsupported expression ⚠️ This value might have side effects -- *12* (???*13* ? ???*14* : 4) +- *12* module["unstable_now"]() ⚠️ nested operation - *13* unsupported expression ⚠️ This value might have side effects -- *14* (???*15* ? 16 : 536870912) - ⚠️ nested operation -- *15* (0 !== ???*16*) +- *14* module["unstable_now"]() ⚠️ nested operation -- *16* unsupported expression +- *15* unsupported expression ⚠️ This value might have side effects -- *17* arguments[0] - ⚠️ function calls are not analysed yet -- *18* ???*19*["value"] - ⚠️ unknown object -- *19* arguments[1] - ⚠️ function calls are not analysed yet -- *20* ???*21*["event"] - ⚠️ unknown object +- *16* unsupported expression ⚠️ This value might have side effects -- *21* FreeVar(window) - ⚠️ unknown global +- *17* Ck + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *22* (???*23* === ???*24*) +- *18* ???*19*["current"] + ⚠️ unknown object +- *19* b + ⚠️ circular variable reference +- *20* C + ⚠️ circular variable reference +- *21* (0 !== ???*22*) ⚠️ nested operation +- *22* C + ⚠️ circular variable reference - *23* unsupported expression ⚠️ This value might have side effects -- *24* a +- *24* C ⚠️ circular variable reference - -0 -> 6438 call = ???*0*() -- *0* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 6439 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*1* | ???*2* | ???*4*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[2] +- *25* unsupported expression + ⚠️ This value might have side effects +- *26* (???*27* ? ???*28* : 1) + ⚠️ nested operation +- *27* unsupported expression + ⚠️ This value might have side effects +- *28* (???*29* ? ???*30* : 4) + ⚠️ nested operation +- *29* unsupported expression + ⚠️ This value might have side effects +- *30* (???*31* ? 16 : 536870912) + ⚠️ nested operation +- *31* (0 !== ???*32*) + ⚠️ nested operation +- *32* unsupported expression + ⚠️ This value might have side effects +- *33* arguments[0] ⚠️ function calls are not analysed yet -- *2* ???*3*["parentNode"] - ⚠️ unknown object -- *3* c - ⚠️ circular variable reference -- *4* ???*5*["querySelectorAll"]( - `input[name=${FreeVar(JSON)["stringify"](`${b}`)}][type="radio"]` - ) - ⚠️ unknown callee object -- *5* c - ⚠️ circular variable reference - -0 -> 6442 conditional = (("radio" === ???*0*) | (null != (???*2* | ???*3* | 0 | ???*5*))) -- *0* ???*1*["type"] +- *34* ???*35*["value"] ⚠️ unknown object -- *1* arguments[2] +- *35* arguments[1] ⚠️ function calls are not analysed yet -- *2* arguments[1] +- *36* arguments[0] ⚠️ function calls are not analysed yet -- *3* ???*4*["name"] +- *37* ???*38*["event"] ⚠️ unknown object -- *4* arguments[2] - ⚠️ function calls are not analysed yet -- *5* updated with update expression ⚠️ This value might have side effects - -6442 -> 6447 free var = FreeVar(JSON) - -6442 -> 6448 member call = ???*0*["stringify"]((???*1* | ???*2* | 0 | ???*4*)) -- *0* FreeVar(JSON) +- *38* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* ???*3*["name"] - ⚠️ unknown object -- *3* arguments[2] - ⚠️ function calls are not analysed yet -- *4* updated with update expression +- *39* (???*40* === ???*41*) + ⚠️ nested operation +- *40* unsupported expression ⚠️ This value might have side effects - -6442 -> 6449 member call = (???*0* | ???*1* | ???*3*)["querySelectorAll"](`input[name=${???*5*}][type="radio"]`) -- *0* arguments[2] - ⚠️ function calls are not analysed yet -- *1* ???*2*["parentNode"] - ⚠️ unknown object -- *2* c - ⚠️ circular variable reference -- *3* ???*4*["querySelectorAll"]( - `input[name=${FreeVar(JSON)["stringify"](`${b}`)}][type="radio"]` - ) - ⚠️ unknown callee object -- *4* c +- *41* a ⚠️ circular variable reference -- *5* ???*6*["stringify"](b) - ⚠️ unknown callee object - ⚠️ This value might have side effects -- *6* FreeVar(JSON) - ⚠️ unknown global +- *42* unsupported expression ⚠️ This value might have side effects - -6442 -> 6454 conditional = ((???*0* !== ???*6*) | (???*7* === ???*14*)) -- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] - ⚠️ unknown object +- *43* Ck + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* ???*4*["name"] +- *44* ???*45*["current"] ⚠️ unknown object -- *4* arguments[2] +- *45* arguments[1] ⚠️ function calls are not analysed yet -- *5* updated with update expression +- *46* FreeVar(undefined) + ⚠️ unknown global ⚠️ This value might have side effects -- *6* arguments[0] - ⚠️ function calls are not analysed yet -- *7* ???*8*["form"] - ⚠️ unknown object +- *47* unknown mutation ⚠️ This value might have side effects -- *8* ???*9*[(???*10* | ???*11* | 0 | ???*13*)] - ⚠️ unknown object +- *48* C + ⚠️ circular variable reference +- *49* (0 !== ???*50*) + ⚠️ nested operation +- *50* C + ⚠️ circular variable reference +- *51* unsupported expression ⚠️ This value might have side effects -- *9* arguments[2] - ⚠️ function calls are not analysed yet -- *10* arguments[1] - ⚠️ function calls are not analysed yet -- *11* ???*12*["name"] - ⚠️ unknown object -- *12* arguments[2] - ⚠️ function calls are not analysed yet -- *13* updated with update expression +- *52* C + ⚠️ circular variable reference +- *53* unsupported expression ⚠️ This value might have side effects -- *14* ???*15*["form"] - ⚠️ unknown object -- *15* arguments[0] - ⚠️ function calls are not analysed yet - -6454 -> 6455 call = (...) => (a[Pf] || null)(???*0*) -- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] - ⚠️ unknown object +- *54* (???*55* ? ???*56* : 1) + ⚠️ nested operation +- *55* unsupported expression ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* ???*4*["name"] - ⚠️ unknown object -- *4* arguments[2] - ⚠️ function calls are not analysed yet -- *5* updated with update expression +- *56* (???*57* ? ???*58* : 4) + ⚠️ nested operation +- *57* unsupported expression ⚠️ This value might have side effects - -6454 -> 6456 conditional = !((???*0* | null)) -- *0* ???*1*[Pf] - ⚠️ unknown object +- *58* (???*59* ? 16 : 536870912) + ⚠️ nested operation +- *59* (0 !== ???*60*) + ⚠️ nested operation +- *60* unsupported expression ⚠️ This value might have side effects -- *1* ???*2*[(???*3* | ???*4* | 0 | ???*6*)] +- *61* arguments[0] + ⚠️ function calls are not analysed yet +- *62* ???*63*["value"] ⚠️ unknown object - ⚠️ This value might have side effects -- *2* arguments[2] +- *63* arguments[1] ⚠️ function calls are not analysed yet -- *3* arguments[1] +- *64* arguments[0] ⚠️ function calls are not analysed yet -- *4* ???*5*["name"] +- *65* ???*66*["event"] ⚠️ unknown object -- *5* arguments[2] - ⚠️ function calls are not analysed yet -- *6* updated with update expression ⚠️ This value might have side effects - -6456 -> 6457 free var = FreeVar(Error) - -6456 -> 6458 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(90) - -6456 -> 6459 call = ???*0*( - `Minified React error #${90}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) +- *66* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${90}` +- *67* (???*68* === ???*69*) ⚠️ nested operation - -6454 -> 6460 call = (...) => (!(1) | !(0) | ((a !== c) ? !(0) : !(1)))(???*0*) -- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] - ⚠️ unknown object - ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* ???*4*["name"] - ⚠️ unknown object -- *4* arguments[2] - ⚠️ function calls are not analysed yet -- *5* updated with update expression +- *68* unsupported expression ⚠️ This value might have side effects +- *69* a + ⚠️ circular variable reference -6454 -> 6461 call = (...) => (undefined | FreeVar(undefined))(???*0*, (???*6* | null)) -- *0* ???*1*[(???*2* | ???*3* | 0 | ???*5*)] - ⚠️ unknown object +0 -> 7154 call = (...) => undefined( + ???*0*, + (???*1* | ???*3* | ???*4*), + ( + | 1 + | ???*5* + | ???*6* + | ???*7* + | ???*9* + | ???*10* + | 0 + | ???*11* + | 4 + | ((???*12* | ???*14*) ? ???*15* : 4) + | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) + | ???*27* + | ???*28* + | (???*30* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ), + (???*33* ? ???*35* : ???*36*) +) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* ???*4*["name"] +- *1* ???*2*["current"] ⚠️ unknown object -- *4* arguments[2] +- *2* arguments[1] ⚠️ function calls are not analysed yet -- *5* updated with update expression +- *3* FreeVar(undefined) + ⚠️ unknown global ⚠️ This value might have side effects -- *6* ???*7*[Pf] - ⚠️ unknown object +- *4* unknown mutation ⚠️ This value might have side effects -- *7* ???*8*[(???*9* | ???*10* | 0 | ???*12*)] - ⚠️ unknown object +- *5* unsupported expression ⚠️ This value might have side effects -- *8* arguments[2] - ⚠️ function calls are not analysed yet -- *9* arguments[1] - ⚠️ function calls are not analysed yet -- *10* ???*11*["name"] +- *6* Ck + ⚠️ sequence with side effects + ⚠️ This value might have side effects +- *7* ???*8*["current"] ⚠️ unknown object -- *11* arguments[2] +- *8* arguments[1] ⚠️ function calls are not analysed yet -- *12* updated with update expression +- *9* FreeVar(undefined) + ⚠️ unknown global ⚠️ This value might have side effects - -0 -> 6462 call = (...) => undefined(???*0*, (???*1* | ???*2* | ???*4*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[2] - ⚠️ function calls are not analysed yet -- *2* ???*3*["parentNode"] - ⚠️ unknown object -- *3* c +- *10* unknown mutation + ⚠️ This value might have side effects +- *11* C ⚠️ circular variable reference -- *4* ???*5*["querySelectorAll"]( - `input[name=${FreeVar(JSON)["stringify"](`${b}`)}][type="radio"]` - ) - ⚠️ unknown callee object -- *5* c +- *12* (0 !== ???*13*) + ⚠️ nested operation +- *13* C ⚠️ circular variable reference - -0 -> 6465 call = (...) => (undefined | FreeVar(undefined))(???*0*, !(???*1*), (???*4* | ???*5* | 0 | ???*7*), false) -- *0* arguments[0] +- *14* unsupported expression + ⚠️ This value might have side effects +- *15* C + ⚠️ circular variable reference +- *16* unsupported expression + ⚠️ This value might have side effects +- *17* (???*18* ? ???*19* : 1) + ⚠️ nested operation +- *18* unsupported expression + ⚠️ This value might have side effects +- *19* (???*20* ? ???*21* : 4) + ⚠️ nested operation +- *20* unsupported expression + ⚠️ This value might have side effects +- *21* (???*22* ? 16 : 536870912) + ⚠️ nested operation +- *22* (0 !== ???*23*) + ⚠️ nested operation +- *23* unsupported expression + ⚠️ This value might have side effects +- *24* arguments[0] ⚠️ function calls are not analysed yet -- *1* !(???*2*) - ⚠️ nested operation -- *2* ???*3*["multiple"] +- *25* ???*26*["value"] ⚠️ unknown object -- *3* arguments[2] +- *26* arguments[1] ⚠️ function calls are not analysed yet -- *4* arguments[1] +- *27* arguments[0] ⚠️ function calls are not analysed yet -- *5* ???*6*["name"] +- *28* ???*29*["event"] ⚠️ unknown object -- *6* arguments[2] - ⚠️ function calls are not analysed yet -- *7* updated with update expression ⚠️ This value might have side effects - -0 -> 6471 call = (...) => ((null !== a) ? $b(a) : null)(???*0*) -- *0* max number of linking steps reached +- *29* FreeVar(window) + ⚠️ unknown global ⚠️ This value might have side effects - -0 -> 6472 conditional = ???*0* -- *0* max number of linking steps reached +- *30* (???*31* === ???*32*) + ⚠️ nested operation +- *31* unsupported expression ⚠️ This value might have side effects - -0 -> 6475 free var = FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - -0 -> 6476 conditional = ("undefined" !== ???*0*) -- *0* typeof(???*1*) +- *32* a + ⚠️ circular variable reference +- *33* (0 !== ???*34*) ⚠️ nested operation -- *1* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global +- *34* unsupported expression ⚠️ This value might have side effects - -6476 -> 6477 free var = FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - -6476 -> 6480 conditional = (!(???*0*) | ???*2*) -- *0* ???*1*["isDisabled"] - ⚠️ unknown object +- *35* module["unstable_now"]() + ⚠️ nested operation +- *36* (???*37* ? (???*41* | ???*42*) : ???*43*) + ⚠️ nested operation +- *37* (???*38* !== (???*39* | ???*40*)) + ⚠️ nested operation +- *38* unsupported expression ⚠️ This value might have side effects -- *1* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global +- *39* unsupported expression ⚠️ This value might have side effects -- *2* ???*3*["supportsFiber"] - ⚠️ unknown object +- *40* module["unstable_now"]() + ⚠️ nested operation +- *41* unsupported expression ⚠️ This value might have side effects -- *3* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) - ⚠️ unknown global +- *42* module["unstable_now"]() + ⚠️ nested operation +- *43* unsupported expression ⚠️ This value might have side effects -6480 -> 6482 member call = ???*0*["inject"]( - { - "bundleType": (0 | ???*1*), - "version": ("18.2.0" | ???*2*), - "rendererPackageName": ("react-dom" | ???*3*), - "rendererConfig": (???*4* | ???*5*), - "overrideHookState": null, - "overrideHookStateDeletePath": null, - "overrideHookStateRenamePath": null, - "overrideProps": null, - "overridePropsDeletePath": null, - "overridePropsRenamePath": null, - "setErrorHandler": null, - "setSuspenseHandler": null, - "scheduleUpdate": null, - "currentDispatcherRef": module["__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"]["ReactCurrentDispatcher"], - "findHostInstanceByFiber": (...) => ((null === a) ? null : a["stateNode"]), - "findFiberByHostInstance": ((...) => (b | c | null) | ???*6* | (...) => null){truthy}, - "findHostInstancesForRefresh": null, - "scheduleRefresh": null, - "scheduleRoot": null, - "setRefreshHandler": null, - "getCurrentFiber": null, - "reconcilerVersion": "18.2.0-next-9e3b772b8-20220608" - } +0 -> 7155 call = (...) => undefined( + ???*0*, + (???*1* | ???*3* | ???*4*), + ( + | 1 + | ???*5* + | ???*6* + | ???*7* + | ???*9* + | ???*10* + | 0 + | ???*11* + | 4 + | ((???*12* | ???*14*) ? ???*15* : 4) + | (???*16* ? 16 : (???*17* | null | ???*24* | ???*25*)) + | ???*27* + | ???*28* + | (???*30* ? 16 : (undefined | 1 | 4 | 16 | 536870912)) + ) ) -- *0* FreeVar(__REACT_DEVTOOLS_GLOBAL_HOOK__) +- *0* max number of linking steps reached + ⚠️ This value might have side effects +- *1* ???*2*["current"] + ⚠️ unknown object +- *2* arguments[1] + ⚠️ function calls are not analysed yet +- *3* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects -- *1* unknown mutation +- *4* unknown mutation ⚠️ This value might have side effects -- *2* unknown mutation +- *5* unsupported expression ⚠️ This value might have side effects -- *3* unknown mutation +- *6* Ck + ⚠️ sequence with side effects ⚠️ This value might have side effects -- *4* FreeVar(undefined) +- *7* ???*8*["current"] + ⚠️ unknown object +- *8* arguments[1] + ⚠️ function calls are not analysed yet +- *9* FreeVar(undefined) ⚠️ unknown global ⚠️ This value might have side effects -- *5* unknown mutation - ⚠️ This value might have side effects -- *6* unknown mutation +- *10* unknown mutation ⚠️ This value might have side effects - -0 -> 6484 free var = FreeVar(exports) - -0 -> 6486 free var = FreeVar(exports) - -0 -> 6488 free var = FreeVar(arguments) - -0 -> 6490 free var = FreeVar(arguments) - -0 -> 6491 conditional = (???*0* | (???*1* !== ???*2*)) -- *0* unsupported expression +- *11* C + ⚠️ circular variable reference +- *12* (0 !== ???*13*) + ⚠️ nested operation +- *13* C + ⚠️ circular variable reference +- *14* unsupported expression ⚠️ This value might have side effects -- *1* unsupported expression +- *15* C + ⚠️ circular variable reference +- *16* unsupported expression ⚠️ This value might have side effects -- *2* ???*3*[2] - ⚠️ unknown object +- *17* (???*18* ? ???*19* : 1) + ⚠️ nested operation +- *18* unsupported expression ⚠️ This value might have side effects -- *3* FreeVar(arguments) - ⚠️ unknown global +- *19* (???*20* ? ???*21* : 4) + ⚠️ nested operation +- *20* unsupported expression ⚠️ This value might have side effects - -6491 -> 6493 free var = FreeVar(arguments) - -0 -> 6494 call = (...) => !(( - || !(a) - || ((1 !== a["nodeType"]) && (9 !== a["nodeType"]) && (11 !== a["nodeType"])) -))(???*0*) -- *0* arguments[1] - ⚠️ function calls are not analysed yet - -0 -> 6495 conditional = !(???*0*) -- *0* !(???*1*) +- *21* (???*22* ? 16 : 536870912) ⚠️ nested operation -- *1* !(???*2*) +- *22* (0 !== ???*23*) ⚠️ nested operation -- *2* arguments[1] - ⚠️ function calls are not analysed yet - -6495 -> 6496 free var = FreeVar(Error) - -6495 -> 6497 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) - -6495 -> 6498 call = ???*0*( - `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *23* unsupported expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` - ⚠️ nested operation - -0 -> 6499 call = (...) => { - "$$typeof": wa, - "key": ((null == d) ? null : `${d}`), - "children": a, - "containerInfo": b, - "implementation": c -}(???*0*, ???*1*, null, ((???*2* | ???*3*) ? ???*7* : null)) -- *0* arguments[0] +- *24* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[1] +- *25* ???*26*["value"] + ⚠️ unknown object +- *26* arguments[1] ⚠️ function calls are not analysed yet -- *2* unsupported expression - ⚠️ This value might have side effects -- *3* (???*4* !== ???*5*) - ⚠️ nested operation -- *4* unsupported expression - ⚠️ This value might have side effects -- *5* ???*6*[2] +- *27* arguments[0] + ⚠️ function calls are not analysed yet +- *28* ???*29*["event"] ⚠️ unknown object ⚠️ This value might have side effects -- *6* FreeVar(arguments) +- *29* FreeVar(window) ⚠️ unknown global ⚠️ This value might have side effects -- *7* ???*8*[2] - ⚠️ unknown object - ⚠️ This value might have side effects -- *8* FreeVar(arguments) - ⚠️ unknown global +- *30* (???*31* === ???*32*) + ⚠️ nested operation +- *31* unsupported expression ⚠️ This value might have side effects +- *32* a + ⚠️ circular variable reference -0 -> 6501 free var = FreeVar(exports) - -0 -> 6502 call = (...) => !(( - || !(a) - || ((1 !== a["nodeType"]) && (9 !== a["nodeType"]) && (11 !== a["nodeType"])) -))(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +0 -> 7156 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 6503 conditional = !(???*0*) -- *0* !(???*1*) - ⚠️ nested operation -- *1* !(???*2*) - ⚠️ nested operation -- *2* arguments[0] +0 -> 7159 conditional = !(???*0*) +- *0* ???*1*["child"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet -6503 -> 6504 free var = FreeVar(Error) +7159 -> 7160 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -6503 -> 6505 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(299) +7159 -> 7165 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -6503 -> 6506 call = ???*0*( - `Minified React error #${299}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +7159 -> 7168 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${299}` - ⚠️ nested operation -0 -> 6512 call = (...) => a( - ???*0*, - 1, - false, - null, - null, - (false | true), - false, - ("" | ???*1* | ???*3*), - ((???*5* ? ???*8* : (...) => undefined) | ???*9* | ???*11*) -) +0 -> 7171 conditional = ((null !== (???*0* | ???*1*)) | (null !== ???*3*)) - *0* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*["identifierPrefix"] - ⚠️ unknown object -- *2* arguments[1] - ⚠️ function calls are not analysed yet -- *3* ???*4*["identifierPrefix"] +- *1* ???*2*["memoizedState"] ⚠️ unknown object - ⚠️ This value might have side effects -- *4* unknown new expression - ⚠️ This value might have side effects -- *5* ("function" === ???*6*) - ⚠️ nested operation -- *6* typeof(???*7*) - ⚠️ nested operation -- *7* FreeVar(reportError) - ⚠️ unknown global - ⚠️ This value might have side effects -- *8* FreeVar(reportError) - ⚠️ unknown global - ⚠️ This value might have side effects -- *9* ???*10*["onRecoverableError"] +- *2* a + ⚠️ circular variable reference +- *3* ???*4*["dehydrated"] ⚠️ unknown object -- *10* arguments[1] +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *11* ???*12*["onRecoverableError"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *12* unknown new expression - ⚠️ This value might have side effects -0 -> 6516 conditional = (8 === ???*0*) -- *0* ???*1*["nodeType"] +7171 -> 7174 conditional = ((0 !== ???*0*) | ???*2*) +- *0* ???*1*["retryLane"] ⚠️ unknown object - *1* arguments[0] ⚠️ function calls are not analysed yet +- *2* unsupported expression + ⚠️ This value might have side effects -0 -> 6518 call = (...) => undefined((???*0* ? ???*3* : ???*5*)) -- *0* (8 === ???*1*) - ⚠️ nested operation -- *1* ???*2*["nodeType"] - ⚠️ unknown object -- *2* arguments[0] +0 -> 7175 call = (...) => undefined((???*0* | ???*1*), ???*3*) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *3* ???*4*["parentNode"] +- *1* ???*2*["alternate"] ⚠️ unknown object -- *4* arguments[0] - ⚠️ function calls are not analysed yet -- *5* arguments[0] +- *2* a + ⚠️ circular variable reference +- *3* arguments[1] ⚠️ function calls are not analysed yet -0 -> 6520 free var = FreeVar(exports) - -0 -> 6523 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +0 -> 7177 call = (...) => undefined((???*0* | ???*1*), ???*3*) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["alternate"] + ⚠️ unknown object +- *2* a + ⚠️ circular variable reference +- *3* arguments[1] + ⚠️ function calls are not analysed yet -6523 -> 6525 conditional = ???*0* -- *0* max number of linking steps reached +0 -> 7178 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -6525 -> 6526 free var = FreeVar(Error) +0 -> 7179 free var = FreeVar(reportError) -6525 -> 6527 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(188) - -6525 -> 6528 call = ???*0*( - `Minified React error #${188}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) +0 -> 7180 conditional = ("function" === ???*0*) +- *0* typeof(???*1*) + ⚠️ nested operation +- *1* FreeVar(reportError) ⚠️ unknown global ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${188}` - ⚠️ nested operation -6523 -> 6531 free var = FreeVar(Object) +7180 -> 7181 free var = FreeVar(reportError) -6523 -> 6532 member call = ???*0*["keys"](???*1*) -- *0* FreeVar(Object) +7180 -> 7183 free var = FreeVar(console) + +7180 -> 7184 member call = ???*0*["error"](???*1*) +- *0* FreeVar(console) ⚠️ unknown global ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects +- *1* arguments[0] + ⚠️ function calls are not analysed yet -6523 -> 6533 member call = ???*0*["join"](",") -- *0* ???*1*["keys"](a) - ⚠️ unknown callee object +0 -> 7191 conditional = (null === ???*0*) +- *0* ???*1*["_internalRoot"] + ⚠️ unknown object ⚠️ This value might have side effects -- *1* FreeVar(Object) - ⚠️ unknown global +- *1* unsupported expression ⚠️ This value might have side effects -6523 -> 6534 free var = FreeVar(Error) +7191 -> 7192 free var = FreeVar(Error) -6523 -> 6535 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(268, ???*0*) -- *0* max number of linking steps reached - ⚠️ This value might have side effects +7191 -> 7193 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(409) -6523 -> 6536 call = ???*0*(???*1*) +7191 -> 7194 call = ???*0*( + `Minified React error #${409}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` +) - *0* FreeVar(Error) ⚠️ unknown global ⚠️ This value might have side effects -- *1* max number of linking steps reached - ⚠️ This value might have side effects +- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${409}` + ⚠️ nested operation -0 -> 6537 call = (...) => ((null !== a) ? $b(a) : null)(???*0*) -- *0* max number of linking steps reached +0 -> 7195 call = (...) => g(???*0*, ???*1*, null, null) +- *0* arguments[0] + ⚠️ function calls are not analysed yet +- *1* ???*2*["_internalRoot"] + ⚠️ unknown object ⚠️ This value might have side effects - -0 -> 6538 conditional = ???*0* -- *0* max number of linking steps reached +- *2* unsupported expression ⚠️ This value might have side effects -0 -> 6541 free var = FreeVar(exports) +0 -> 7201 conditional = (null !== ???*0*) +- *0* ???*1*["_internalRoot"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects -0 -> 6542 call = (...) => (undefined | a())(???*0*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet +7201 -> 7204 call = (...) => (undefined | a())((...) => undefined) -0 -> 6544 free var = FreeVar(exports) +7204 -> 7205 call = (...) => g(null, ???*0*, null, null) +- *0* ???*1*["_internalRoot"] + ⚠️ unknown object + ⚠️ This value might have side effects +- *1* unsupported expression + ⚠️ This value might have side effects -0 -> 6545 call = (...) => !(( - || !(a) - || ( - && (1 !== a["nodeType"]) - && (9 !== a["nodeType"]) - && (11 !== a["nodeType"]) - && ( - || (8 !== a["nodeType"]) - || (" react-mount-point-unstable " !== a["nodeValue"]) +0 -> 7210 conditional = ( + | ???*0* + | { + "blockedOn": null, + "target": ???*1*, + "priority": ( + | ???*2*() + | 0 + | 1 + | ???*3* + | 4 + | ((???*4* | ???*6*) ? ???*7* : 4) + | (???*8* ? 16 : (???*9* | null | ???*16* | ???*17*)) + | ???*19* ) - ) -))(???*0*) -- *0* arguments[1] + } +) +- *0* arguments[0] ⚠️ function calls are not analysed yet - -0 -> 6546 conditional = !(???*0*) -- *0* !(???*1*) +- *1* a + ⚠️ circular variable reference +- *2* Hc + ⚠️ pattern without value +- *3* C + ⚠️ circular variable reference +- *4* (0 !== ???*5*) ⚠️ nested operation -- *1* !(???*2*) +- *5* C + ⚠️ circular variable reference +- *6* unsupported expression + ⚠️ This value might have side effects +- *7* C + ⚠️ circular variable reference +- *8* unsupported expression + ⚠️ This value might have side effects +- *9* (???*10* ? ???*11* : 1) ⚠️ nested operation -- *2* arguments[1] - ⚠️ function calls are not analysed yet - -6546 -> 6547 free var = FreeVar(Error) - -6546 -> 6548 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) - -6546 -> 6549 call = ???*0*( - `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *10* unsupported expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` +- *11* (???*12* ? ???*13* : 4) ⚠️ nested operation - -0 -> 6550 call = (...) => hl(g)(null, ???*0*, ???*1*, true, ???*2*) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* arguments[1] - ⚠️ function calls are not analysed yet -- *2* arguments[2] - ⚠️ function calls are not analysed yet - -0 -> 6552 free var = FreeVar(exports) - -0 -> 6553 call = (...) => !(( - || !(a) - || ((1 !== a["nodeType"]) && (9 !== a["nodeType"]) && (11 !== a["nodeType"])) -))((???*0* | 0 | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* updated with update expression +- *12* unsupported expression ⚠️ This value might have side effects - -0 -> 6554 conditional = !(???*0*) -- *0* !(???*1*) +- *13* (???*14* ? 16 : 536870912) ⚠️ nested operation -- *1* !((???*2* | 0 | ???*3*)) +- *14* (0 !== ???*15*) ⚠️ nested operation -- *2* arguments[0] - ⚠️ function calls are not analysed yet -- *3* updated with update expression - ⚠️ This value might have side effects - -6554 -> 6555 free var = FreeVar(Error) - -6554 -> 6556 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(405) - -6554 -> 6557 call = ???*0*( - `Minified React error #${405}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *15* unsupported expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${405}` - ⚠️ nested operation - -0 -> 6564 conditional = (null != (???*0* | ???*1* | null[(???*6* | 0 | ???*7*)])) -- *0* arguments[2] +- *16* arguments[0] ⚠️ function calls are not analysed yet -- *1* ???*2*[(???*4* | 0 | ???*5*)] +- *17* ???*18*["value"] ⚠️ unknown object - ⚠️ This value might have side effects -- *2* (null != ???*3*) - ⚠️ nested operation -- *3* c - ⚠️ circular variable reference -- *4* arguments[0] +- *18* arguments[1] ⚠️ function calls are not analysed yet -- *5* updated with update expression - ⚠️ This value might have side effects -- *6* arguments[0] +- *19* arguments[0] ⚠️ function calls are not analysed yet -- *7* updated with update expression - ⚠️ This value might have side effects -0 -> 6565 call = (...) => a( - ???*0*, - null, - (???*1* | 0 | ???*2*), - 1, - (???*3* ? (???*12* | ???*13* | null[(???*18* | 0 | ???*19*)]) : null), - ( - | false - | true - | ???*20* - | (null != ???*22*)[(???*23* | 0 | ???*24*)]["_getVersion"] - | ???*25* - | null[(???*31* | 0 | ???*32*)]["_getVersion"] - | ???*33* - ), - false, - ( - | "" - | ???*35* - | (null != ???*37*)[(???*38* | 0 | ???*39*)]["identifierPrefix"] - | ???*40* - | null[(???*46* | 0 | ???*47*)]["identifierPrefix"] - ), +7210 -> 7211 call = (???*0* | (...) => C)() +- *0* Hc + ⚠️ pattern without value + +7210 -> 7216 member call = []["splice"]( + (0 | ???*0*), + 0, ( - | (???*48* ? ???*51* : (...) => undefined) - | ???*52* - | (null != ???*54*)[(???*55* | 0 | ???*56*)]["onRecoverableError"] - | ???*57* - | null[(???*63* | 0 | ???*64*)]["onRecoverableError"] + | ???*1* + | { + "blockedOn": null, + "target": ???*2*, + "priority": ( + | ???*3*() + | 0 + | 1 + | ???*4* + | 4 + | ((???*5* | ???*7*) ? ???*8* : 4) + | (???*9* ? 16 : (???*10* | null | ???*17* | ???*18*)) + | ???*20* + ) + } ) ) -- *0* max number of linking steps reached +- *0* updated with update expression ⚠️ This value might have side effects - *1* arguments[0] ⚠️ function calls are not analysed yet -- *2* updated with update expression - ⚠️ This value might have side effects -- *3* (null != (???*4* | ???*5* | null[(???*10* | 0 | ???*11*)])) +- *2* a + ⚠️ circular variable reference +- *3* Hc + ⚠️ pattern without value +- *4* C + ⚠️ circular variable reference +- *5* (0 !== ???*6*) ⚠️ nested operation -- *4* arguments[2] - ⚠️ function calls are not analysed yet -- *5* ???*6*[(???*8* | 0 | ???*9*)] - ⚠️ unknown object +- *6* C + ⚠️ circular variable reference +- *7* unsupported expression ⚠️ This value might have side effects -- *6* (null != ???*7*) - ⚠️ nested operation -- *7* c +- *8* C ⚠️ circular variable reference -- *8* arguments[0] - ⚠️ function calls are not analysed yet -- *9* updated with update expression +- *9* unsupported expression ⚠️ This value might have side effects -- *10* arguments[0] - ⚠️ function calls are not analysed yet -- *11* updated with update expression +- *10* (???*11* ? ???*12* : 1) + ⚠️ nested operation +- *11* unsupported expression ⚠️ This value might have side effects -- *12* arguments[2] - ⚠️ function calls are not analysed yet -- *13* ???*14*[(???*16* | 0 | ???*17*)] - ⚠️ unknown object +- *12* (???*13* ? ???*14* : 4) + ⚠️ nested operation +- *13* unsupported expression ⚠️ This value might have side effects -- *14* (null != ???*15*) +- *14* (???*15* ? 16 : 536870912) ⚠️ nested operation -- *15* c - ⚠️ circular variable reference -- *16* arguments[0] - ⚠️ function calls are not analysed yet -- *17* updated with update expression +- *15* (0 !== ???*16*) + ⚠️ nested operation +- *16* unsupported expression ⚠️ This value might have side effects -- *18* arguments[0] +- *17* arguments[0] ⚠️ function calls are not analysed yet -- *19* updated with update expression - ⚠️ This value might have side effects -- *20* ???*21*["_getVersion"] +- *18* ???*19*["value"] ⚠️ unknown object -- *21* arguments[2] - ⚠️ function calls are not analysed yet -- *22* c - ⚠️ circular variable reference -- *23* arguments[0] +- *19* arguments[1] ⚠️ function calls are not analysed yet -- *24* updated with update expression - ⚠️ This value might have side effects -- *25* ???*26*["_getVersion"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *26* ???*27*[(???*29* | 0 | ???*30*)] - ⚠️ unknown object - ⚠️ This value might have side effects -- *27* ???*28*["hydratedSources"] - ⚠️ unknown object -- *28* c - ⚠️ circular variable reference -- *29* arguments[0] +- *20* arguments[0] ⚠️ function calls are not analysed yet -- *30* updated with update expression - ⚠️ This value might have side effects -- *31* arguments[0] + +7210 -> 7217 call = (...) => (undefined | FreeVar(undefined))( + ( + | ???*0* + | { + "blockedOn": null, + "target": ???*1*, + "priority": ( + | ???*2*() + | 0 + | 1 + | ???*3* + | 4 + | ((???*4* | ???*6*) ? ???*7* : 4) + | (???*8* ? 16 : (???*9* | null | ???*16* | ???*17*)) + | ???*19* + ) + } + ) +) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *32* updated with update expression - ⚠️ This value might have side effects -- *33* ???*34*(c["_source"]) - ⚠️ unknown callee -- *34* e +- *1* a ⚠️ circular variable reference -- *35* ???*36*["identifierPrefix"] - ⚠️ unknown object -- *36* arguments[2] - ⚠️ function calls are not analysed yet -- *37* c +- *2* Hc + ⚠️ pattern without value +- *3* C ⚠️ circular variable reference -- *38* arguments[0] - ⚠️ function calls are not analysed yet -- *39* updated with update expression - ⚠️ This value might have side effects -- *40* ???*41*["identifierPrefix"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *41* ???*42*[(???*44* | 0 | ???*45*)] - ⚠️ unknown object - ⚠️ This value might have side effects -- *42* ???*43*["hydratedSources"] - ⚠️ unknown object -- *43* c +- *4* (0 !== ???*5*) + ⚠️ nested operation +- *5* C ⚠️ circular variable reference -- *44* arguments[0] - ⚠️ function calls are not analysed yet -- *45* updated with update expression +- *6* unsupported expression ⚠️ This value might have side effects -- *46* arguments[0] - ⚠️ function calls are not analysed yet -- *47* updated with update expression +- *7* C + ⚠️ circular variable reference +- *8* unsupported expression ⚠️ This value might have side effects -- *48* ("function" === ???*49*) +- *9* (???*10* ? ???*11* : 1) ⚠️ nested operation -- *49* typeof(???*50*) +- *10* unsupported expression + ⚠️ This value might have side effects +- *11* (???*12* ? ???*13* : 4) ⚠️ nested operation -- *50* FreeVar(reportError) - ⚠️ unknown global +- *12* unsupported expression ⚠️ This value might have side effects -- *51* FreeVar(reportError) - ⚠️ unknown global +- *13* (???*14* ? 16 : 536870912) + ⚠️ nested operation +- *14* (0 !== ???*15*) + ⚠️ nested operation +- *15* unsupported expression ⚠️ This value might have side effects -- *52* ???*53*["onRecoverableError"] - ⚠️ unknown object -- *53* arguments[2] - ⚠️ function calls are not analysed yet -- *54* c - ⚠️ circular variable reference -- *55* arguments[0] +- *16* arguments[0] ⚠️ function calls are not analysed yet -- *56* updated with update expression - ⚠️ This value might have side effects -- *57* ???*58*["onRecoverableError"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *58* ???*59*[(???*61* | 0 | ???*62*)] - ⚠️ unknown object - ⚠️ This value might have side effects -- *59* ???*60*["hydratedSources"] +- *17* ???*18*["value"] ⚠️ unknown object -- *60* c - ⚠️ circular variable reference -- *61* arguments[0] +- *18* arguments[1] ⚠️ function calls are not analysed yet -- *62* updated with update expression - ⚠️ This value might have side effects -- *63* arguments[0] +- *19* arguments[0] ⚠️ function calls are not analysed yet -- *64* updated with update expression + +0 -> 7221 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 6568 call = (...) => undefined((???*0* | 0 | ???*1*)) -- *0* arguments[0] - ⚠️ function calls are not analysed yet -- *1* updated with update expression +0 -> 7227 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -0 -> 6569 conditional = ((null != (???*0* | ???*1*)) | ???*3* | null) -- *0* arguments[2] +0 -> 7228 conditional = (???*0* | ???*1*) +- *0* arguments[4] ⚠️ function calls are not analysed yet -- *1* ???*2*[a] - ⚠️ unknown object -- *2* d - ⚠️ circular variable reference -- *3* ???*4*["hydratedSources"] +- *1* ???*2*["lastChild"] ⚠️ unknown object -- *4* arguments[2] +- *2* arguments[0] ⚠️ function calls are not analysed yet -6569 -> 6574 call = ( - | false - | true - | ???*0* - | (null != ???*2*)[(???*3* | 0 | ???*4*)]["_getVersion"] - | ???*5* - | null[(???*11* | 0 | ???*12*)]["_getVersion"] - | ???*13* -)( - ( - | ???*15* - | (null != ???*17*)[(???*18* | 0 | ???*19*)]["_source"] - | ???*20* - | null[(???*26* | 0 | ???*27*)]["_source"] - ) -) -- *0* ???*1*["_getVersion"] - ⚠️ unknown object -- *1* arguments[2] +7228 -> 7229 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | (...) => undefined)) + ⚠️ nested operation +- *1* arguments[3] ⚠️ function calls are not analysed yet -- *2* c - ⚠️ circular variable reference -- *3* arguments[0] + +7229 -> 7230 call = (...) => (undefined | null | a["child"]["stateNode"])((???*0* | ???*1* | ???*3*)) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *4* updated with update expression - ⚠️ This value might have side effects -- *5* ???*6*["_getVersion"] - ⚠️ unknown object - ⚠️ This value might have side effects -- *6* ???*7*[(???*9* | 0 | ???*10*)] - ⚠️ unknown object - ⚠️ This value might have side effects -- *7* ???*8*["hydratedSources"] +- *1* ???*2*["current"] ⚠️ unknown object -- *8* c +- *2* a ⚠️ circular variable reference -- *9* arguments[0] - ⚠️ function calls are not analysed yet -- *10* updated with update expression +- *3* unknown new expression ⚠️ This value might have side effects -- *11* arguments[0] + +7229 -> 7232 member call = (???*0* | (...) => undefined)["call"](???*1*) +- *0* arguments[3] ⚠️ function calls are not analysed yet -- *12* updated with update expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *13* ???*14*(c["_source"]) - ⚠️ unknown callee -- *14* e - ⚠️ circular variable reference -- *15* ???*16*["_source"] - ⚠️ unknown object -- *16* arguments[2] + +7228 -> 7233 call = (...) => a(???*0*, (???*1* | (...) => undefined), ???*2*, 0, null, false, false, "", (...) => undefined) +- *0* arguments[1] ⚠️ function calls are not analysed yet -- *17* c - ⚠️ circular variable reference -- *18* arguments[0] +- *1* arguments[3] ⚠️ function calls are not analysed yet -- *19* updated with update expression - ⚠️ This value might have side effects -- *20* ???*21*["_source"] +- *2* arguments[0] + ⚠️ function calls are not analysed yet + +7228 -> 7238 conditional = (8 === ???*0*) +- *0* ???*1*["nodeType"] ⚠️ unknown object - ⚠️ This value might have side effects -- *21* ???*22*[(???*24* | 0 | ???*25*)] +- *1* arguments[0] + ⚠️ function calls are not analysed yet + +7228 -> 7240 call = (...) => undefined((???*0* ? ???*3* : ???*5*)) +- *0* (8 === ???*1*) + ⚠️ nested operation +- *1* ???*2*["nodeType"] ⚠️ unknown object - ⚠️ This value might have side effects -- *22* ???*23*["hydratedSources"] +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* ???*4*["parentNode"] ⚠️ unknown object -- *23* c - ⚠️ circular variable reference -- *24* arguments[0] +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *25* updated with update expression - ⚠️ This value might have side effects -- *26* arguments[0] +- *5* arguments[0] ⚠️ function calls are not analysed yet -- *27* updated with update expression - ⚠️ This value might have side effects -6569 -> 6576 conditional = ???*0* -- *0* max number of linking steps reached - ⚠️ This value might have side effects +7228 -> 7241 call = (...) => (undefined | a())() -6576 -> 6580 member call = ???*0*["push"]( - (???*1* | (null != ???*2*)[(???*3* | 0 | ???*4*)] | ???*5* | null[(???*10* | 0 | ???*11*)]), - ( - | false - | true - | ???*12* - | (null != ???*14*)[(???*15* | 0 | ???*16*)]["_getVersion"] - | ???*17* - | null[(???*23* | 0 | ???*24*)]["_getVersion"] - | ???*25* - ) -) -- *0* max number of linking steps reached +7228 -> 7242 unreachable = ???*0* +- *0* unreachable ⚠️ This value might have side effects -- *1* arguments[2] + +7228 -> 7245 member call = ???*0*["removeChild"]((???*1* | ???*2*)) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *2* c - ⚠️ circular variable reference -- *3* arguments[0] +- *1* arguments[4] ⚠️ function calls are not analysed yet -- *4* updated with update expression - ⚠️ This value might have side effects -- *5* ???*6*[(???*8* | 0 | ???*9*)] - ⚠️ unknown object - ⚠️ This value might have side effects -- *6* ???*7*["hydratedSources"] +- *2* ???*3*["lastChild"] ⚠️ unknown object -- *7* c - ⚠️ circular variable reference -- *8* arguments[0] - ⚠️ function calls are not analysed yet -- *9* updated with update expression - ⚠️ This value might have side effects -- *10* arguments[0] +- *3* arguments[0] ⚠️ function calls are not analysed yet -- *11* updated with update expression - ⚠️ This value might have side effects -- *12* ???*13*["_getVersion"] - ⚠️ unknown object -- *13* arguments[2] + +7228 -> 7246 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | (...) => undefined)) + ⚠️ nested operation +- *1* arguments[3] ⚠️ function calls are not analysed yet -- *14* c - ⚠️ circular variable reference -- *15* arguments[0] + +7246 -> 7247 call = (...) => (undefined | null | a["child"]["stateNode"])((???*0* | ???*1*)) +- *0* arguments[0] ⚠️ function calls are not analysed yet -- *16* updated with update expression +- *1* unknown new expression ⚠️ This value might have side effects -- *17* ???*18*["_getVersion"] + +7246 -> 7249 member call = (???*0* | (...) => undefined)["call"]((undefined | null | ???*1* | ???*4*)) +- *0* arguments[3] + ⚠️ function calls are not analysed yet +- *1* ???*2*["stateNode"] ⚠️ unknown object - ⚠️ This value might have side effects -- *18* ???*19*[(???*21* | 0 | ???*22*)] +- *2* ???*3*["child"] + ⚠️ unknown object +- *3* arguments[0] + ⚠️ function calls are not analysed yet +- *4* ???*5*["stateNode"] ⚠️ unknown object ⚠️ This value might have side effects -- *19* ???*20*["hydratedSources"] +- *5* ???*6*["child"] ⚠️ unknown object -- *20* c - ⚠️ circular variable reference -- *21* arguments[0] - ⚠️ function calls are not analysed yet -- *22* updated with update expression ⚠️ This value might have side effects -- *23* arguments[0] - ⚠️ function calls are not analysed yet -- *24* updated with update expression +- *6* unknown new expression ⚠️ This value might have side effects -- *25* ???*26*(c["_source"]) - ⚠️ unknown callee -- *26* e - ⚠️ circular variable reference -0 -> 6582 free var = FreeVar(exports) - -0 -> 6583 call = (...) => !(( - || !(a) - || ( - && (1 !== a["nodeType"]) - && (9 !== a["nodeType"]) - && (11 !== a["nodeType"]) - && ( - || (8 !== a["nodeType"]) - || (" react-mount-point-unstable " !== a["nodeValue"]) - ) - ) -))(???*0*) -- *0* arguments[1] +7228 -> 7250 call = (...) => a(???*0*, 0, false, null, null, false, false, "", (...) => undefined) +- *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 6584 conditional = !(???*0*) -- *0* !(???*1*) - ⚠️ nested operation -- *1* !(???*2*) - ⚠️ nested operation -- *2* arguments[1] +7228 -> 7255 conditional = (8 === ???*0*) +- *0* ???*1*["nodeType"] + ⚠️ unknown object +- *1* arguments[0] ⚠️ function calls are not analysed yet -6584 -> 6585 free var = FreeVar(Error) - -6584 -> 6586 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) - -6584 -> 6587 call = ???*0*( - `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global - ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` +7228 -> 7257 call = (...) => undefined((???*0* ? ???*3* : ???*5*)) +- *0* (8 === ???*1*) ⚠️ nested operation - -0 -> 6588 call = (...) => hl(g)(null, ???*0*, ???*1*, false, ???*2*) -- *0* arguments[0] +- *1* ???*2*["nodeType"] + ⚠️ unknown object +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *1* arguments[1] +- *3* ???*4*["parentNode"] + ⚠️ unknown object +- *4* arguments[0] ⚠️ function calls are not analysed yet -- *2* arguments[2] +- *5* arguments[0] ⚠️ function calls are not analysed yet -0 -> 6590 free var = FreeVar(exports) +7228 -> 7258 call = (...) => (undefined | a())((...) => undefined) -0 -> 6591 call = (...) => !(( - || !(a) - || ( - && (1 !== a["nodeType"]) - && (9 !== a["nodeType"]) - && (11 !== a["nodeType"]) - && ( - || (8 !== a["nodeType"]) - || (" react-mount-point-unstable " !== a["nodeValue"]) - ) - ) -))(???*0*) -- *0* arguments[0] +7258 -> 7259 call = (...) => g(???*0*, (???*1* | ???*2*), ???*3*, (???*4* | (...) => undefined)) +- *0* arguments[1] ⚠️ function calls are not analysed yet - -0 -> 6592 conditional = !(???*0*) -- *0* !(???*1*) - ⚠️ nested operation -- *1* !(???*2*) - ⚠️ nested operation -- *2* arguments[0] +- *1* arguments[0] ⚠️ function calls are not analysed yet - -6592 -> 6593 free var = FreeVar(Error) - -6592 -> 6594 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(40) - -6592 -> 6595 call = ???*0*( - `Minified React error #${40}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +- *2* unknown new expression ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${40}` - ⚠️ nested operation - -0 -> 6597 conditional = ???*0* -- *0* ???*1*["_reactRootContainer"] - ⚠️ unknown object -- *1* arguments[0] +- *3* arguments[2] ⚠️ function calls are not analysed yet - -6597 -> 6598 call = (...) => (undefined | a())((...) => undefined) - -6598 -> 6599 call = (...) => hl(g)(null, null, ???*0*, false, (...) => undefined) -- *0* arguments[0] +- *4* arguments[3] ⚠️ function calls are not analysed yet -0 -> 6603 free var = FreeVar(exports) - -0 -> 6605 free var = FreeVar(exports) +7228 -> 7260 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects -0 -> 6606 call = (...) => !(( - || !(a) - || ( - && (1 !== a["nodeType"]) - && (9 !== a["nodeType"]) - && (11 !== a["nodeType"]) - && ( - || (8 !== a["nodeType"]) - || (" react-mount-point-unstable " !== a["nodeValue"]) - ) - ) -))(???*0*) -- *0* arguments[2] +0 -> 7262 conditional = ???*0* +- *0* ???*1*["_reactRootContainer"] + ⚠️ unknown object +- *1* arguments[2] ⚠️ function calls are not analysed yet -0 -> 6607 conditional = !(???*0*) -- *0* !(???*1*) - ⚠️ nested operation -- *1* !(???*2*) +7262 -> 7263 conditional = ("function" === ???*0*) +- *0* typeof((???*1* | (...) => undefined)) ⚠️ nested operation -- *2* arguments[2] +- *1* arguments[4] ⚠️ function calls are not analysed yet -6607 -> 6608 free var = FreeVar(Error) - -6607 -> 6609 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(200) - -6607 -> 6610 call = ???*0*( - `Minified React error #${200}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +7263 -> 7264 call = (...) => (undefined | null | a["child"]["stateNode"])(???*0*) +- *0* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${200}` - ⚠️ nested operation -0 -> 6612 conditional = ((null == ???*0*) | (???*1* === ???*2*)) -- *0* arguments[0] +7263 -> 7266 member call = (???*0* | (...) => undefined)["call"](???*1*) +- *0* arguments[4] ⚠️ function calls are not analysed yet -- *1* unsupported expression +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *2* ???*3*["_reactInternals"] - ⚠️ unknown object -- *3* arguments[0] - ⚠️ function calls are not analysed yet - -6612 -> 6613 free var = FreeVar(Error) -6612 -> 6614 call = (...) => `Minified React error #${a}; visit ${b} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`(38) - -6612 -> 6615 call = ???*0*( - `Minified React error #${38}; visit ${???*1*} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.` -) -- *0* FreeVar(Error) - ⚠️ unknown global +7262 -> 7267 call = (...) => g(???*0*, ???*1*, ???*2*, (???*3* | (...) => undefined)) +- *0* arguments[1] + ⚠️ function calls are not analysed yet +- *1* max number of linking steps reached ⚠️ This value might have side effects -- *1* `https://reactjs.org/docs/error-decoder.html?invariant=${38}` - ⚠️ nested operation +- *2* arguments[0] + ⚠️ function calls are not analysed yet +- *3* arguments[4] + ⚠️ function calls are not analysed yet -0 -> 6616 call = (...) => hl(g)(???*0*, ???*1*, ???*2*, false, ???*3*) -- *0* arguments[0] +7262 -> 7268 call = (...) => (g | k)(???*0*, ???*1*, ???*2*, (???*3* | (...) => undefined), ???*4*) +- *0* arguments[2] ⚠️ function calls are not analysed yet - *1* arguments[1] ⚠️ function calls are not analysed yet -- *2* arguments[2] +- *2* arguments[0] ⚠️ function calls are not analysed yet -- *3* arguments[3] +- *3* arguments[4] + ⚠️ function calls are not analysed yet +- *4* arguments[3] ⚠️ function calls are not analysed yet -0 -> 6618 free var = FreeVar(exports) +0 -> 7269 call = (...) => (undefined | null | a["child"]["stateNode"])(???*0*) +- *0* max number of linking steps reached + ⚠️ This value might have side effects + +0 -> 7270 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/graph-effects.snapshot index f0b6438b9d9a6..6f5ac271dc3c3 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/graph-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/graph-effects.snapshot @@ -1,26 +1,12 @@ [ Member { - obj: MemberCall( - 3, - Variable( - ( - "r", - #3, - ), - ), - Constant( - Str( - Atom( - "keys", - ), - ), - ), - [], + obj: FreeVar( + "require", ), prop: Constant( Str( Atom( - "map", + "context", ), ), ), @@ -30,31 +16,22 @@ ), Script( Body( - 0, + 1, ), ), Stmt( Decl, ), Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, + Var, ), - BlockStmt( - Stmts( + VarDecl( + Decls( 0, ), ), - Stmt( - Return, - ), - ReturnStmt( - Arg, + VarDeclarator( + Init, ), Expr( Call, @@ -69,22 +46,12 @@ Member, ), ], - span: 34..46#0, + span: 70..85#0, in_try: false, }, - Member { - obj: Variable( - ( - "r", - #3, - ), - ), - prop: Constant( - Str( - Atom( - "keys", - ), - ), + FreeVar { + var: FreeVar( + "require", ), ast_path: [ Program( @@ -92,31 +59,22 @@ ), Script( Body( - 0, + 1, ), ), Stmt( Decl, ), Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, + Var, ), - BlockStmt( - Stmts( + VarDecl( + Decls( 0, ), ), - Stmt( - Return, - ), - ReturnStmt( - Arg, + VarDeclarator( + Init, ), Expr( Call, @@ -134,121 +92,90 @@ Obj, ), Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, + Ident, ), ], - span: 34..40#0, + span: 70..77#1, in_try: false, }, MemberCall { - obj: Variable( - ( - "r", - #3, - ), + obj: FreeVar( + "require", ), prop: Constant( Str( Atom( - "keys", + "context", ), ), ), - args: [], + args: [ + Value( + Constant( + Str( + Word( + "./test", + ), + ), + ), + ), + Value( + Constant( + False, + ), + ), + Value( + Constant( + Regex( + "\\.test\\.js$", + "", + ), + ), + ), + ], ast_path: [ Program( Script, ), Script( Body( - 0, + 1, ), ), Stmt( Decl, ), Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, + Var, ), - BlockStmt( - Stmts( + VarDecl( + Decls( 0, ), ), - Stmt( - Return, - ), - ReturnStmt( - Arg, - ), - Expr( - Call, - ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, + VarDeclarator( + Init, ), Expr( Call, ), ], - span: 34..42#0, + span: 70..117#0, in_try: false, }, - MemberCall { - obj: MemberCall( - 3, - Variable( - ( - "r", - #3, - ), - ), - Constant( - Str( - Atom( - "keys", - ), - ), - ), - [], - ), - prop: Constant( - Str( - Atom( - "map", - ), + Call { + func: Variable( + ( + "importAll", + #2, ), ), args: [ Value( Variable( ( - "r", - #3, + "context", + #2, ), ), ), @@ -259,47 +186,41 @@ ), Script( Body( - 0, + 2, ), ), Stmt( Decl, ), Decl( - Fn, - ), - FnDecl( - Function, - ), - Function( - Body, + Var, ), - BlockStmt( - Stmts( + VarDecl( + Decls( 0, ), ), - Stmt( - Return, - ), - ReturnStmt( - Arg, + VarDeclarator( + Init, ), Expr( Call, ), ], - span: 34..49#0, + span: 133..151#0, in_try: false, }, Member { - obj: FreeVar( - "require", + obj: Variable( + ( + "context", + #2, + ), ), prop: Constant( Str( Atom( - "context", + "resolve", ), ), ), @@ -309,7 +230,7 @@ ), Script( Body( - 1, + 3, ), ), Stmt( @@ -339,25 +260,46 @@ Member, ), ], - span: 70..85#0, + span: 164..179#0, in_try: false, }, - FreeVar { - var: FreeVar( - "require", - ), - ast_path: [ - Program( - Script, + MemberCall { + obj: Variable( + ( + "context", + #2, ), - Script( - Body( - 1, + ), + prop: Constant( + Str( + Atom( + "resolve", ), ), - Stmt( - Decl, - ), + ), + args: [ + Value( + Constant( + Str( + Word( + "./a", + ), + ), + ), + ), + ], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), Decl( Var, ), @@ -372,173 +314,206 @@ Expr( Call, ), - CallExpr( - Callee, - ), - Callee( - Expr, - ), - Expr( - Member, - ), - MemberExpr( - Obj, - ), - Expr( - Ident, - ), ], - span: 70..77#1, + span: 164..186#0, in_try: false, }, - MemberCall { - obj: FreeVar( - "require", - ), - prop: Constant( - Str( - Atom( - "context", + Member { + obj: MemberCall( + 3, + Variable( + ( + "r", + #3, ), ), - ), - args: [ - Value( - Constant( - Str( - Word( - "./test", - ), + Constant( + Str( + Atom( + "keys", ), ), ), - Value( - Constant( - False, - ), - ), - Value( - Constant( - Regex( - "\\.test\\.js$", - "", - ), + [], + ), + prop: Constant( + Str( + Atom( + "map", ), ), - ], + ), ast_path: [ Program( Script, ), Script( Body( - 1, + 0, ), ), Stmt( Decl, ), Decl( - Var, + Fn, ), - VarDecl( - Decls( + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( 0, ), ), - VarDeclarator( - Init, + Stmt( + Return, + ), + ReturnStmt( + Arg, ), Expr( Call, ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), ], - span: 70..117#0, + span: 34..46#0, in_try: false, }, - Call { - func: Variable( + Member { + obj: Variable( ( - "importAll", - #2, + "r", + #3, ), ), - args: [ - Value( - Variable( - ( - "context", - #2, - ), + prop: Constant( + Str( + Atom( + "keys", ), ), - ], + ), ast_path: [ Program( Script, ), Script( Body( - 2, + 0, ), ), Stmt( Decl, ), Decl( - Var, + Fn, ), - VarDecl( - Decls( + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( 0, ), ), - VarDeclarator( - Init, + Stmt( + Return, + ), + ReturnStmt( + Arg, ), Expr( Call, ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), + MemberExpr( + Obj, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Member, + ), ], - span: 133..151#0, + span: 34..40#0, in_try: false, }, - Member { + MemberCall { obj: Variable( ( - "context", - #2, + "r", + #3, ), ), prop: Constant( Str( Atom( - "resolve", + "keys", ), ), ), + args: [], ast_path: [ Program( Script, ), Script( Body( - 3, + 0, ), ), Stmt( Decl, ), Decl( - Var, + Fn, ), - VarDecl( - Decls( + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( 0, ), ), - VarDeclarator( - Init, + Stmt( + Return, + ), + ReturnStmt( + Arg, ), Expr( Call, @@ -552,31 +527,47 @@ Expr( Member, ), + MemberExpr( + Obj, + ), + Expr( + Call, + ), ], - span: 164..179#0, + span: 34..42#0, in_try: false, }, MemberCall { - obj: Variable( - ( - "context", - #2, + obj: MemberCall( + 3, + Variable( + ( + "r", + #3, + ), + ), + Constant( + Str( + Atom( + "keys", + ), + ), ), + [], ), prop: Constant( Str( Atom( - "resolve", + "map", ), ), ), args: [ Value( - Constant( - Str( - Word( - "./a", - ), + Variable( + ( + "r", + #3, ), ), ), @@ -587,28 +578,69 @@ ), Script( Body( - 3, + 0, ), ), Stmt( Decl, ), Decl( - Var, + Fn, ), - VarDecl( - Decls( + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( 0, ), ), - VarDeclarator( - Init, + Stmt( + Return, + ), + ReturnStmt( + Arg, ), Expr( Call, ), ], - span: 164..186#0, + span: 34..49#0, in_try: false, }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Return, + ), + ], + }, ] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/resolved-effects.snapshot index 6474685303239..1db615e8a7243 100644 --- a/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/resolved-effects.snapshot +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/require-context/resolved-effects.snapshot @@ -1,8 +1,19 @@ -0 -> 3 member call = ???*0*["keys"]() +0 -> 2 free var = FreeVar(require) + +0 -> 3 member call = require*0*["context"]("./test", false, /\.test\.js$/) +- *0* require: The require method from CommonJS + +0 -> 4 call = (...) => r["keys"]()["map"](r)(require.context(...)*0*) +- *0* require.context(...): The require.context(...) method from webpack: https://webpack.js.org/api/module-methods/#requirecontext + +0 -> 6 member call = require.context(...)*0*["resolve"]("./a") +- *0* require.context(...): The require.context(...) method from webpack: https://webpack.js.org/api/module-methods/#requirecontext + +0 -> 9 member call = ???*0*["keys"]() - *0* arguments[0] ⚠️ function calls are not analysed yet -0 -> 4 member call = ???*0*()["map"](???*2*) +0 -> 10 member call = ???*0*()["map"](???*2*) - *0* ???*1*["keys"] ⚠️ unknown object - *1* arguments[0] @@ -10,13 +21,6 @@ - *2* arguments[0] ⚠️ function calls are not analysed yet -0 -> 6 free var = FreeVar(require) - -0 -> 7 member call = require*0*["context"]("./test", false, /\.test\.js$/) -- *0* require: The require method from CommonJS - -0 -> 8 call = (...) => r["keys"]()["map"](r)(require.context(...)*0*) -- *0* require.context(...): The require.context(...) method from webpack: https://webpack.js.org/api/module-methods/#requirecontext - -0 -> 10 member call = require.context(...)*0*["resolve"]("./a") -- *0* require.context(...): The require.context(...) method from webpack: https://webpack.js.org/api/module-methods/#requirecontext +0 -> 11 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-effects.snapshot new file mode 100644 index 0000000000000..82ce69a875c54 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-effects.snapshot @@ -0,0 +1,1763 @@ +[ + FreeVar { + var: FreeVar( + "a1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 18..20#1, + in_try: false, + }, + Call { + func: FreeVar( + "a1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 18..22#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + FreeVar { + var: FreeVar( + "b1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + While, + ), + WhileStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 82..84#1, + in_try: false, + }, + Call { + func: FreeVar( + "b1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + While, + ), + WhileStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 82..86#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + While, + ), + WhileStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 1, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + While, + ), + WhileStmt( + Body, + ), + Stmt( + Block, + ), + ], + }, + FreeVar { + var: FreeVar( + "c1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + DoWhile, + ), + DoWhileStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 151..153#1, + in_try: false, + }, + Call { + func: FreeVar( + "c1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + DoWhile, + ), + DoWhileStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 151..155#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + DoWhile, + ), + DoWhileStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 2, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + DoWhile, + ), + DoWhileStmt( + Body, + ), + Stmt( + Block, + ), + ], + }, + FreeVar { + var: FreeVar( + "d1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + For, + ), + ForStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 241..243#1, + in_try: false, + }, + Call { + func: FreeVar( + "d1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + For, + ), + ForStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 241..245#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + For, + ), + ForStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 3, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + For, + ), + ForStmt( + Body, + ), + Stmt( + Block, + ), + ], + }, + FreeVar { + var: FreeVar( + "e1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForIn, + ), + ForInStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 325..327#1, + in_try: false, + }, + Call { + func: FreeVar( + "e1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForIn, + ), + ForInStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 325..329#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForIn, + ), + ForInStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 4, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForIn, + ), + ForInStmt( + Body, + ), + Stmt( + Block, + ), + ], + }, + FreeVar { + var: FreeVar( + "f1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForOf, + ), + ForOfStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 409..411#1, + in_try: false, + }, + Call { + func: FreeVar( + "f1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForOf, + ), + ForOfStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 409..413#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForOf, + ), + ForOfStmt( + Body, + ), + Stmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 5, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + ForOf, + ), + ForOfStmt( + Body, + ), + Stmt( + Block, + ), + ], + }, + FreeVar { + var: FreeVar( + "g1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 479..481#1, + in_try: true, + }, + Call { + func: FreeVar( + "g1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 479..483#0, + in_try: true, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Block, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + FreeVar { + var: FreeVar( + "g3", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 527..529#1, + in_try: false, + }, + Call { + func: FreeVar( + "g3", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 6, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Try, + ), + TryStmt( + Handler, + ), + CatchClause( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 527..531#0, + in_try: false, + }, + FreeVar { + var: FreeVar( + "h1", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 579..581#1, + in_try: false, + }, + Call { + func: FreeVar( + "h1", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 579..583#0, + in_try: false, + }, + Unreachable { + start_ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 0, + ), + ), + Stmt( + Decl, + ), + Decl( + Var, + ), + VarDecl( + Decls( + 0, + ), + ), + VarDeclarator( + Init, + ), + Expr( + Arrow, + ), + ArrowExpr( + Body, + ), + BlockStmtOrExpr( + BlockStmt, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Return, + ), + ], + }, + FreeVar { + var: FreeVar( + "h3", + ), + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + CallExpr( + Callee, + ), + Callee( + Expr, + ), + Expr( + Ident, + ), + ], + span: 614..616#1, + in_try: false, + }, + Call { + func: FreeVar( + "h3", + ), + args: [], + ast_path: [ + Program( + Script, + ), + Script( + Body( + 7, + ), + ), + Stmt( + Decl, + ), + Decl( + Fn, + ), + FnDecl( + Function, + ), + Function( + Body, + ), + BlockStmt( + Stmts( + 1, + ), + ), + Stmt( + Expr, + ), + ExprStmt( + Expr, + ), + Expr( + Call, + ), + ], + span: 614..618#0, + in_try: false, + }, +] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-explained.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-explained.snapshot new file mode 100644 index 0000000000000..7e3e114e7b9b6 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph-explained.snapshot @@ -0,0 +1,29 @@ +*arrow function 567* = (...) => (undefined | FreeVar(undefined)) + +a = (...) => (undefined | FreeVar(undefined)) + +b = (...) => (undefined | FreeVar(undefined)) + +c = (...) => (undefined | FreeVar(undefined)) + +d = (...) => (undefined | FreeVar(undefined)) + +e#16 = ???*0* +- *0* e + ⚠️ pattern without value + +e#2 = (...) => (undefined | FreeVar(undefined)) + +f = (...) => (undefined | FreeVar(undefined)) + +g = (...) => (undefined | FreeVar(undefined)) + +h = (...) => undefined + +x#10 = ???*0* +- *0* x + ⚠️ pattern without value + +x#17 = *arrow function 567* + +y = Iterated([]) diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph.snapshot new file mode 100644 index 0000000000000..f41a54167872b --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/graph.snapshot @@ -0,0 +1,214 @@ +[ + ( + "*arrow function 567*", + Function( + 4, + 567, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "a", + Function( + 4, + 1, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "b", + Function( + 4, + 45, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "c", + Function( + 4, + 125, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "d", + Function( + 4, + 209, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "e#16", + Unknown { + original_value: Some( + Variable( + ( + "e", + #16, + ), + ), + ), + reason: "pattern without value", + has_side_effects: false, + }, + ), + ( + "e#2", + Function( + 4, + 284, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "f", + Function( + 4, + 368, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "g", + Function( + 4, + 452, + Alternatives { + total_nodes: 3, + values: [ + Constant( + Undefined, + ), + FreeVar( + "undefined", + ), + ], + logical_property: None, + }, + ), + ), + ( + "h", + Function( + 2, + 540, + Constant( + Undefined, + ), + ), + ), + ( + "x#10", + Unknown { + original_value: Some( + Variable( + ( + "x", + #10, + ), + ), + ), + reason: "pattern without value", + has_side_effects: false, + }, + ), + ( + "x#17", + Variable( + ( + "*arrow function 567*", + #0, + ), + ), + ), + ( + "y", + Iterated( + 2, + Array { + total_nodes: 1, + items: [], + mutable: true, + }, + ), + ), +] diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/input.js b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/input.js new file mode 100644 index 0000000000000..63badf25f3c15 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/input.js @@ -0,0 +1,69 @@ +function a() { + a1(); + return; + a2(); +} + +function b() { + while (false) { + b1(); + return; + b2(); + } + b3(); +} + +function c() { + do { + c1(); + return; + c2(); + } while (false); + c3(); +} + +function d() { + for (;;) { + d1(); + return; + d2(); + } + d3(); +} + +function e() { + for (var x in {}) { + e1(); + return; + e2(); + } + e3(); +} + +function f() { + for (var y of []) { + f1(); + return; + f2(); + } + f3(); +} + +function g() { + try { + g1(); + return; + g2(); + } catch (e) { + g3(); + } +} + +function h() { + const x = () => { + h1(); + return; + h2(); + }; + h3(); +} diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-effects.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-effects.snapshot new file mode 100644 index 0000000000000..aa26e363a6e24 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-effects.snapshot @@ -0,0 +1,121 @@ +0 -> 1 free var = FreeVar(a1) + +0 -> 2 call = ???*0*() +- *0* FreeVar(a1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 3 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 4 free var = FreeVar(b1) + +0 -> 5 call = ???*0*() +- *0* FreeVar(b1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 6 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 7 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 8 free var = FreeVar(c1) + +0 -> 9 call = ???*0*() +- *0* FreeVar(c1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 10 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 11 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 12 free var = FreeVar(d1) + +0 -> 13 call = ???*0*() +- *0* FreeVar(d1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 14 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 15 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 16 free var = FreeVar(e1) + +0 -> 17 call = ???*0*() +- *0* FreeVar(e1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 18 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 19 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 20 free var = FreeVar(f1) + +0 -> 21 call = ???*0*() +- *0* FreeVar(f1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 22 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 23 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 24 free var = FreeVar(g1) + +0 -> 25 call = ???*0*() +- *0* FreeVar(g1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 26 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 27 free var = FreeVar(g3) + +0 -> 28 call = ???*0*() +- *0* FreeVar(g3) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 29 free var = FreeVar(h1) + +0 -> 30 call = ???*0*() +- *0* FreeVar(h1) + ⚠️ unknown global + ⚠️ This value might have side effects + +0 -> 31 unreachable = ???*0* +- *0* unreachable + ⚠️ This value might have side effects + +0 -> 32 free var = FreeVar(h3) + +0 -> 33 call = ???*0*() +- *0* FreeVar(h3) + ⚠️ unknown global + ⚠️ This value might have side effects diff --git a/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-explained.snapshot b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-explained.snapshot new file mode 100644 index 0000000000000..26c71fdcc1a17 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/analyzer/graph/unreachable/resolved-explained.snapshot @@ -0,0 +1,29 @@ +*arrow function 567* = (...) => (undefined | FreeVar(undefined)) + +a = (...) => (undefined | FreeVar(undefined)) + +b = (...) => (undefined | FreeVar(undefined)) + +c = (...) => (undefined | FreeVar(undefined)) + +d = (...) => (undefined | FreeVar(undefined)) + +e#16 = ???*0* +- *0* e + ⚠️ pattern without value + +e#2 = (...) => (undefined | FreeVar(undefined)) + +f = (...) => (undefined | FreeVar(undefined)) + +g = (...) => (undefined | FreeVar(undefined)) + +h = (...) => undefined + +x#10 = ???*0* +- *0* x + ⚠️ pattern without value + +x#17 = (...) => (undefined | FreeVar(undefined)) + +y = () diff --git a/crates/turbopack-tests/tests/execution/turbopack/side-effects-optimization/comptime/input/index.js b/crates/turbopack-tests/tests/execution/turbopack/side-effects-optimization/comptime/input/index.js index 7e2aef16b7a9b..e082085cc32b6 100644 --- a/crates/turbopack-tests/tests/execution/turbopack/side-effects-optimization/comptime/input/index.js +++ b/crates/turbopack-tests/tests/execution/turbopack/side-effects-optimization/comptime/input/index.js @@ -2,9 +2,9 @@ import { something } from "package/dep.js"; import { something2 } from "package/dep2.js"; it("should not include a module that is side effect free and exports are not used due to static analysis", () => { - if (false) { - something(); - } else { + if (true) { something2(); + return; } + something(); }); diff --git a/crates/turbopack-tests/tests/snapshot/comptime/define/output/crates_turbopack-tests_tests_snapshot_comptime_define_input_index_49857f.js.map b/crates/turbopack-tests/tests/snapshot/comptime/define/output/crates_turbopack-tests_tests_snapshot_comptime_define_input_index_49857f.js.map index b469b41139cc4..98f16580d7be3 100644 --- a/crates/turbopack-tests/tests/snapshot/comptime/define/output/crates_turbopack-tests_tests_snapshot_comptime_define_input_index_49857f.js.map +++ b/crates/turbopack-tests/tests/snapshot/comptime/define/output/crates_turbopack-tests_tests_snapshot_comptime_define_input_index_49857f.js.map @@ -2,6 +2,6 @@ "version": 3, "sources": [], "sections": [ - {"offset": {"line": 4, "column": 0}, "map": {"version":3,"sources":["turbopack://[project]/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js"],"sourcesContent":["if (DEFINED_VALUE) {\n console.log('DEFINED_VALUE');\n}\n\nif (DEFINED_TRUE) {\n console.log('DEFINED_VALUE');\n}\n\nif (A.VERY.LONG.DEFINED.VALUE) {\n console.log('A.VERY.LONG.DEFINED.VALUE');\n}\n\nif (process.env.NODE_ENV) {\n console.log('something');\n}\n\nif (process.env.NODE_ENV === 'production') {\n console.log('production');\n}\n\nvar p = process;\n\nconsole.log(A.VERY.LONG.DEFINED.VALUE);\nconsole.log(DEFINED_VALUE);\nconsole.log(p.env.NODE_ENV);\n\nif (p.env.NODE_ENV === 'production') {\n console.log('production');\n}\n\np.env.NODE_ENV == 'production' ? console.log('production') : console.log('development');\n\n// TODO short-circuit is not implemented yet\np.env.NODE_ENV != 'production' && console.log('development');\np.env.NODE_ENV == 'production' && console.log('production');\n"],"names":[],"mappings":"AAAA,wCAAmB;IACjB,QAAQ,GAAG,CAAC;AACd;AAEA,wCAAkB;IAChB,QAAQ,GAAG,CAAC;AACd;AAEA,iEAA+B;IAC7B,QAAQ,GAAG,CAAC;AACd;AAEA,wCAA0B;IACxB,QAAQ,GAAG,CAAC;AACd;AAEA;;;AAIA,IAAI,IAAI;AAER,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AAEX;;;AAIA,6EAA6D,QAAQ,GAAG,CAAC;AAEzE,4CAA4C;AAC5C,mDAAkB,gBAAgB,QAAQ,GAAG,CAAC;AAC9C,mDAAkB,gBAAgB,QAAQ,GAAG,CAAC"}}, + {"offset": {"line": 4, "column": 0}, "map": {"version":3,"sources":["turbopack://[project]/crates/turbopack-tests/tests/snapshot/comptime/define/input/index.js"],"sourcesContent":["if (DEFINED_VALUE) {\n console.log('DEFINED_VALUE');\n}\n\nif (DEFINED_TRUE) {\n console.log('DEFINED_VALUE');\n}\n\nif (A.VERY.LONG.DEFINED.VALUE) {\n console.log('A.VERY.LONG.DEFINED.VALUE');\n}\n\nif (process.env.NODE_ENV) {\n console.log('something');\n}\n\nif (process.env.NODE_ENV === 'production') {\n console.log('production');\n}\n\nvar p = process;\n\nconsole.log(A.VERY.LONG.DEFINED.VALUE);\nconsole.log(DEFINED_VALUE);\nconsole.log(p.env.NODE_ENV);\n\nif (p.env.NODE_ENV === 'production') {\n console.log('production');\n}\n\np.env.NODE_ENV == 'production' ? console.log('production') : console.log('development');\n\n// TODO short-circuit is not implemented yet\np.env.NODE_ENV != 'production' && console.log('development');\np.env.NODE_ENV == 'production' && console.log('production');\n"],"names":[],"mappings":"AAAA,wCAAmB;IACjB,QAAQ,GAAG,CAAC;AACd;AAEA,wCAAkB;IAChB,QAAQ,GAAG,CAAC;AACd;AAEA,iEAA+B;IAC7B,QAAQ,GAAG,CAAC;AACd;AAEA,wCAA0B;IACxB,QAAQ,GAAG,CAAC;AACd;AAEA,uCAA2C;;AAE3C;AAEA,IAAI,IAAI;AAER,QAAQ,GAAG;AACX,QAAQ,GAAG;AACX,QAAQ,GAAG;AAEX,uCAAqC;;AAErC;AAEA,6EAA6D,QAAQ,GAAG,CAAC;AAEzE,4CAA4C;AAC5C,mDAAkB,gBAAgB,QAAQ,GAAG,CAAC;AAC9C,mDAAkB,gBAAgB,QAAQ,GAAG,CAAC"}}, {"offset": {"line": 30, "column": 0}, "map": {"version":3,"sources":[],"names":[],"mappings":"A"}}] } \ No newline at end of file diff --git a/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js b/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js new file mode 100644 index 0000000000000..95fc5090b17c6 --- /dev/null +++ b/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js @@ -0,0 +1,2 @@ +import * as module from "./module"; +console.log(module); diff --git a/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js b/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js new file mode 100644 index 0000000000000..119c82ed32777 --- /dev/null +++ b/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js @@ -0,0 +1,207 @@ +export function a() { + if (true) { + a1(); + return; + } + a2(); + var a3 = 3; + function a4() { + var a5; + } + (function a6() { + var a7; + }); + const a8 = () => { + var a9; + }; + class a10 {} + let a11 = 11; + let { + a12 = 12, + a14: { + a15, + a16: [a17, ...a18], + }, + ...a19 + } = {}; + function a20() { + return; + a21(); + } + ({ + get a22() { + var a23; + }, + set a22(value) { + var a24; + }, + a25() { + var a26; + }, + }); + { + let a27; + var a28; + } +} + +export function b() { + if (true) { + b1(); + return; + } else { + b2(); + } + b3(); +} + +export function c() { + if (true) { + return; + } + c1(); +} + +export function d() { + if (true) { + return; + } else { + d1(); + } + d2(); +} + +export function e() { + if (false) { + e1(); + } else { + return; + } + e2(); +} + +export function f() { + if (false) { + } else { + return; + } + f1(); +} + +export function g() { + if (false) { + g1(); + } else { + g2(); + return; + } + g3(); +} + +export function h() { + if (false) { + } else { + h1(); + return; + } + h2(); +} + +export function i(j) { + if (j < 1) return i1(); + return i2(); +} + +export function j(j) { + if (j < 1) { + return i1(); + } + return i2(); +} + +class K { + constructor() { + try { + k1(); + } catch (e) { + k2(); + return; + k3(); + } finally { + k4(); + } + k5(); + } + + l() { + try { + l1(); + } catch (e) { + l2(); + } finally { + l3(); + return; + l4(); + } + l5(); + } + + get m() { + if (true) { + m1(); + return; + } + m2(); + } + + set m(value) { + m1(); + return m2(); + m3(); + } + + n = () => { + switch (42) { + case 1: + n1(); + return; + n2(); + case 2: + n3(); + break; + default: + n4(); + } + n5(); + }; + + o() { + if (something) { + require("./module"); + return; + } else { + require("./module"); + return; + } + } +} + +function p() { + class C { + constructor() { + p1(); + return; + p2(); + } + } + + p3(); + return; + p4(); +} + +z1(); + +return; + +z2(); diff --git a/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js new file mode 100644 index 0000000000000..66b7b3d9ddcdd --- /dev/null +++ b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js @@ -0,0 +1,191 @@ +(globalThis.TURBOPACK = globalThis.TURBOPACK || []).push(["output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js", { + +"[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js [test] (ecmascript)": (({ r: __turbopack_require__, f: __turbopack_module_context__, i: __turbopack_import__, s: __turbopack_esm__, v: __turbopack_export_value__, n: __turbopack_export_namespace__, c: __turbopack_cache__, M: __turbopack_modules__, l: __turbopack_load__, j: __turbopack_dynamic__, P: __turbopack_resolve_absolute_path__, U: __turbopack_relative_url__, R: __turbopack_resolve_module_id_path__, g: global, __dirname }) => (() => { +"use strict"; + +__turbopack_esm__({ + "a": ()=>a, + "b": ()=>b, + "c": ()=>c, + "d": ()=>d, + "e": ()=>e, + "f": ()=>f, + "g": ()=>g, + "h": ()=>h, + "i": ()=>i, + "j": ()=>j +}); +function a() { + if ("TURBOPACK compile-time truthy", 1) { + a1(); + return; + } + "TURBOPACK unreachable"; + var a3; + function a4() { + var a5; + } + const a8 = undefined; + let a10; + let a11; + let a12, a15, a17, a18, a19; + function a20() { + return; + "TURBOPACK unreachable"; + } + var a28; +} +function b() { + if ("TURBOPACK compile-time truthy", 1) { + b1(); + return; + } else { + "TURBOPACK unreachable"; + } + "TURBOPACK unreachable"; +} +function c() { + if ("TURBOPACK compile-time truthy", 1) { + return; + } + "TURBOPACK unreachable"; +} +function d() { + if ("TURBOPACK compile-time truthy", 1) { + return; + } else { + "TURBOPACK unreachable"; + } + "TURBOPACK unreachable"; +} +function e() { + if ("TURBOPACK compile-time falsy", 0) { + "TURBOPACK unreachable"; + } else { + return; + } + "TURBOPACK unreachable"; +} +function f() { + if ("TURBOPACK compile-time falsy", 0) {} else { + return; + } + "TURBOPACK unreachable"; +} +function g() { + if ("TURBOPACK compile-time falsy", 0) { + "TURBOPACK unreachable"; + } else { + g2(); + return; + } + "TURBOPACK unreachable"; +} +function h() { + if ("TURBOPACK compile-time falsy", 0) {} else { + h1(); + return; + } + "TURBOPACK unreachable"; +} +function i(j) { + if (j < 1) return i1(); + return i2(); +} +function j(j) { + if (j < 1) { + return i1(); + } + return i2(); +} +class K { + constructor(){ + try { + k1(); + } catch (e) { + k2(); + return; + "TURBOPACK unreachable"; + } finally{ + k4(); + } + k5(); + } + l() { + try { + l1(); + } catch (e) { + l2(); + } finally{ + l3(); + return; + "TURBOPACK unreachable"; + } + "TURBOPACK unreachable"; + } + get m() { + if ("TURBOPACK compile-time truthy", 1) { + m1(); + return; + } + "TURBOPACK unreachable"; + } + set m(value) { + m1(); + return m2(); + "TURBOPACK unreachable"; + } + n = ()=>{ + switch(42){ + case 1: + n1(); + return; + "TURBOPACK unreachable"; + case 2: + n3(); + break; + default: + n4(); + } + n5(); + }; + o() { + if (something) { + __turbopack_require__("[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js [test] (ecmascript)"); + return; + } else { + __turbopack_require__("[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js [test] (ecmascript)"); + return; + } + } +} +function p() { + class C { + constructor(){ + p1(); + return; + "TURBOPACK unreachable"; + } + } + p3(); + return; + "TURBOPACK unreachable"; +} +z1(); +return; +z2(); + +})()), +"[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js [test] (ecmascript)": (({ r: __turbopack_require__, f: __turbopack_module_context__, i: __turbopack_import__, s: __turbopack_esm__, v: __turbopack_export_value__, n: __turbopack_export_namespace__, c: __turbopack_cache__, M: __turbopack_modules__, l: __turbopack_load__, j: __turbopack_dynamic__, P: __turbopack_resolve_absolute_path__, U: __turbopack_relative_url__, R: __turbopack_resolve_module_id_path__, g: global, __dirname }) => (() => { +"use strict"; + +__turbopack_esm__({}); +var __TURBOPACK__imported__module__$5b$project$5d2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$comptime$2f$early$2d$return$2f$input$2f$module$2e$js__$5b$test$5d$__$28$ecmascript$29$__ = __turbopack_import__("[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js [test] (ecmascript)"); +"__TURBOPACK__ecmascript__hoisting__location__"; +; +console.log(__TURBOPACK__imported__module__$5b$project$5d2f$crates$2f$turbopack$2d$tests$2f$tests$2f$snapshot$2f$comptime$2f$early$2d$return$2f$input$2f$module$2e$js__$5b$test$5d$__$28$ecmascript$29$__); + +})()), +}]); + +//# sourceMappingURL=crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js.map \ No newline at end of file diff --git a/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js.map b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js.map new file mode 100644 index 0000000000000..5fb8d559029bc --- /dev/null +++ b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js.map @@ -0,0 +1,9 @@ +{ + "version": 3, + "sources": [], + "sections": [ + {"offset": {"line": 5, "column": 0}, "map": {"version":3,"sources":["turbopack://[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/module.js"],"sourcesContent":["export function a() {\n if (true) {\n a1();\n return;\n }\n a2();\n var a3 = 3;\n function a4() {\n var a5;\n }\n (function a6() {\n var a7;\n });\n const a8 = () => {\n var a9;\n };\n class a10 {}\n let a11 = 11;\n let {\n a12 = 12,\n a14: {\n a15,\n a16: [a17, ...a18],\n },\n ...a19\n } = {};\n function a20() {\n return;\n a21();\n }\n ({\n get a22() {\n var a23;\n },\n set a22(value) {\n var a24;\n },\n a25() {\n var a26;\n },\n });\n {\n let a27;\n var a28;\n }\n}\n\nexport function b() {\n if (true) {\n b1();\n return;\n } else {\n b2();\n }\n b3();\n}\n\nexport function c() {\n if (true) {\n return;\n }\n c1();\n}\n\nexport function d() {\n if (true) {\n return;\n } else {\n d1();\n }\n d2();\n}\n\nexport function e() {\n if (false) {\n e1();\n } else {\n return;\n }\n e2();\n}\n\nexport function f() {\n if (false) {\n } else {\n return;\n }\n f1();\n}\n\nexport function g() {\n if (false) {\n g1();\n } else {\n g2();\n return;\n }\n g3();\n}\n\nexport function h() {\n if (false) {\n } else {\n h1();\n return;\n }\n h2();\n}\n\nexport function i(j) {\n if (j < 1) return i1();\n return i2();\n}\n\nexport function j(j) {\n if (j < 1) {\n return i1();\n }\n return i2();\n}\n\nclass K {\n constructor() {\n try {\n k1();\n } catch (e) {\n k2();\n return;\n k3();\n } finally {\n k4();\n }\n k5();\n }\n\n l() {\n try {\n l1();\n } catch (e) {\n l2();\n } finally {\n l3();\n return;\n l4();\n }\n l5();\n }\n\n get m() {\n if (true) {\n m1();\n return;\n }\n m2();\n }\n\n set m(value) {\n m1();\n return m2();\n m3();\n }\n\n n = () => {\n switch (42) {\n case 1:\n n1();\n return;\n n2();\n case 2:\n n3();\n break;\n default:\n n4();\n }\n n5();\n };\n\n o() {\n if (something) {\n require(\"./module\");\n return;\n } else {\n require(\"./module\");\n return;\n }\n }\n}\n\nfunction p() {\n class C {\n constructor() {\n p1();\n return;\n p2();\n }\n }\n\n p3();\n return;\n p4();\n}\n\nz1();\n\nreturn;\n\nz2();\n"],"names":[],"mappings":";;;;;;;;;;;;AAAO,SAAS;IACd,wCAAU;QACR;QACA;IACF;;IAEA,IAAI;IACJ,SAAS;QACP,IAAI;IACN;IAIA,MAAM;IAGA,IAAA;IACN,IAAI;IACJ,IACE,KAEE,KACM,KAAQ,KAEb;IAEL,SAAS;QACP;;IAEF;IAcE,IAAI;AAER;AAEO,SAAS;IACd,wCAAU;QACR;QACA;IACF,OAAO;;IAEP;;AAEF;AAEO,SAAS;IACd,wCAAU;QACR;IACF;;AAEF;AAEO,SAAS;IACd,wCAAU;QACR;IACF,OAAO;;IAEP;;AAEF;AAEO,SAAS;IACd,uCAAW;;IAEX,OAAO;QACL;IACF;;AAEF;AAEO,SAAS;IACd,uCAAW,CACX,OAAO;QACL;IACF;;AAEF;AAEO,SAAS;IACd,uCAAW;;IAEX,OAAO;QACL;QACA;IACF;;AAEF;AAEO,SAAS;IACd,uCAAW,CACX,OAAO;QACL;QACA;IACF;;AAEF;AAEO,SAAS,EAAE,CAAC;IACjB,IAAI,IAAI,GAAG,OAAO;IAClB,OAAO;AACT;AAEO,SAAS,EAAE,CAAC;IACjB,IAAI,IAAI,GAAG;QACT,OAAO;IACT;IACA,OAAO;AACT;AAEA,MAAM;IACJ,aAAc;QACZ,IAAI;YACF;QACF,EAAE,OAAO,GAAG;YACV;YACA;;QAEF,SAAU;YACR;QACF;QACA;IACF;IAEA,IAAI;QACF,IAAI;YACF;QACF,EAAE,OAAO,GAAG;YACV;QACF,SAAU;YACR;YACA;;QAEF;;IAEF;IAEA,IAAI,IAAI;QACN,wCAAU;YACR;YACA;QACF;;IAEF;IAEA,IAAI,EAAE,KAAK,EAAE;QACX;QACA,OAAO;;IAET;IAEA,IAAI;QACF,OAAQ;YACN,KAAK;gBACH;gBACA;;YAEF,KAAK;gBACH;gBACA;YACF;gBACE;QACJ;QACA;IACF,EAAE;IAEF,IAAI;QACF,IAAI,WAAW;;YAEb;QACF,OAAO;;YAEL;QACF;IACF;AACF;AAEA,SAAS;IACP,MAAM;QACJ,aAAc;YACZ;YACA;;QAEF;IACF;IAEA;IACA;;AAEF;AAEA;AAEA;AAEA"}}, + {"offset": {"line": 176, "column": 0}, "map": {"version":3,"sources":[],"names":[],"mappings":"A"}}, + {"offset": {"line": 181, "column": 0}, "map": {"version":3,"sources":["turbopack://[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js"],"sourcesContent":["import * as module from \"./module\";\nconsole.log(module);\n"],"names":[],"mappings":";;;;AACA,QAAQ,GAAG,CAAC"}}, + {"offset": {"line": 186, "column": 0}, "map": {"version":3,"sources":[],"names":[],"mappings":"A"}}] +} \ No newline at end of file diff --git a/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js new file mode 100644 index 0000000000000..39fde74f1d4f3 --- /dev/null +++ b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js @@ -0,0 +1,6 @@ +(globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([ + "output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js", + {}, + {"otherChunks":["output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_99b3d5._.js"],"runtimeModuleIds":["[project]/crates/turbopack-tests/tests/snapshot/comptime/early-return/input/index.js [test] (ecmascript)"]} +]); +// Dummy runtime \ No newline at end of file diff --git a/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js.map b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js.map new file mode 100644 index 0000000000000..c15d7ec00382d --- /dev/null +++ b/crates/turbopack-tests/tests/snapshot/comptime/early-return/output/crates_turbopack-tests_tests_snapshot_comptime_early-return_input_index_c9750a.js.map @@ -0,0 +1,5 @@ +{ + "version": 3, + "sources": [], + "sections": [] +} \ No newline at end of file From 3437a3c0e68c908c9b691cf13483524e769dc112 Mon Sep 17 00:00:00 2001 From: Anthony Shew Date: Thu, 1 Aug 2024 06:31:35 -0600 Subject: [PATCH 2/3] feat(tui): Set TURBO_IS_TUI environment variable when using TUI. (#8897) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ### Description Tools being used inside Turborepo tasks may want to know if they are being ran in our multiplexer, similar to the way other terminal tooling set environment variables that other programs can read (e.g. `ZSH`,`TMUX`, `ALACRITTY_WINDOW_ID`). In this PR, we're exposing a `TURBO_IS_TUI` variable for this purpose. ### Testing Instructions Using the `with-shell-commands` example, I edited one of the `build` scripts to echo the value. With TUI: ``` TURBO_UI devturbo build --force --skip-infer ┌ pkg-b#build > cache bypass, force executing 33b029c222753bd2 │ │ │ > pkg-b@ prebuild /Users/anthonyshew/projects/debugs/with-shell-commands/packages/pkg-b │ > echo "Executing pre-build step..." │ │ Executing pre-build step... │ │ > pkg-b@ build /Users/anthonyshew/projects/debugs/with-shell-commands/packages/pkg-b │ > echo $TURBO_IS_TUI │ │ true └────> ``` Without TUI: ``` TURBO_UI=0 devturbo build --force --skip-infer --filter=pkg-b turbo 2.0.11 • Packages in scope: pkg-b • Running build in 1 packages • Remote caching disabled pkg-b:prebuild: > echo "Executing pre-build step..." pkg-b:prebuild: pkg-b:prebuild: Executing pre-build step... pkg-b:build: cache bypass, force executing 33b029c222753bd2 pkg-b:build: pkg-b:build: pkg-b:build: > pkg-b@ prebuild /Users/anthonyshew/projects/debugs/with-shell-commands/packages/pkg-b pkg-b:build: > echo "Executing pre-build step..." pkg-b:build: pkg-b:build: Executing pre-build step... pkg-b:build: pkg-b:build: > pkg-b@ build /Users/anthonyshew/projects/debugs/with-shell-commands/packages/pkg-b pkg-b:build: > echo $TURBO_IS_TUI pkg-b:build: pkg-b:build: ``` --- crates/turborepo-lib/src/task_graph/visitor.rs | 6 ++++++ docs/repo-docs/reference/system-environment-variables.mdx | 7 ++++--- grep | 0 3 files changed, 10 insertions(+), 3 deletions(-) create mode 100644 grep diff --git a/crates/turborepo-lib/src/task_graph/visitor.rs b/crates/turborepo-lib/src/task_graph/visitor.rs index 27f301ca42c3b..e34f35548c277 100644 --- a/crates/turborepo-lib/src/task_graph/visitor.rs +++ b/crates/turborepo-lib/src/task_graph/visitor.rs @@ -912,6 +912,12 @@ impl ExecContext { cmd.envs(self.execution_env.iter()); // Always last to make sure it overwrites any user configured env var. cmd.env("TURBO_HASH", &self.task_hash); + + // Allow downstream tools to detect if the task is being ran with TUI + if self.experimental_ui { + cmd.env("TURBO_IS_TUI", "true"); + } + // enable task access tracing // set the trace file env var - frameworks that support this can use it to diff --git a/docs/repo-docs/reference/system-environment-variables.mdx b/docs/repo-docs/reference/system-environment-variables.mdx index 2ebb267f09ba7..255a6ad45f25b 100644 --- a/docs/repo-docs/reference/system-environment-variables.mdx +++ b/docs/repo-docs/reference/system-environment-variables.mdx @@ -39,6 +39,7 @@ System environment variables are always overridden by flag values provided direc Turborepo will make the following environment variables available within your tasks while they are executing: -| Variable | Description | -| ------------ | --------------------------------------- | -| `TURBO_HASH` | The hash of the currently running task. | +| Variable | Description | +| -------------- | -------------------------------------------------------------------------------------------- | +| `TURBO_HASH` | The hash of the currently running task. | +| `TURBO_IS_TUI` | When using the [TUI](/repo/docs/reference/configuration#ui), this variable is set to `true`. | diff --git a/grep b/grep new file mode 100644 index 0000000000000..e69de29bb2d1d From d4f2a5ff262c654a299304d0a36483814a4e524f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Thu, 1 Aug 2024 08:58:02 -0400 Subject: [PATCH 3/3] release(turborepo): 2.0.12-canary.0 (#8901) Co-authored-by: Turbobot --- packages/create-turbo/package.json | 2 +- packages/eslint-config-turbo/package.json | 2 +- packages/eslint-plugin-turbo/package.json | 2 +- packages/turbo-codemod/package.json | 2 +- packages/turbo-gen/package.json | 2 +- packages/turbo-ignore/package.json | 2 +- packages/turbo-types/package.json | 2 +- packages/turbo-workspaces/package.json | 2 +- packages/turbo/package.json | 14 +++++++------- version.txt | 4 ++-- 10 files changed, 17 insertions(+), 17 deletions(-) diff --git a/packages/create-turbo/package.json b/packages/create-turbo/package.json index 924003345618c..788212a20e995 100644 --- a/packages/create-turbo/package.json +++ b/packages/create-turbo/package.json @@ -1,6 +1,6 @@ { "name": "create-turbo", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "Create a new Turborepo", "homepage": "https://turbo.build/repo", "license": "MIT", diff --git a/packages/eslint-config-turbo/package.json b/packages/eslint-config-turbo/package.json index 73c6da32f236c..711459a819cb4 100644 --- a/packages/eslint-config-turbo/package.json +++ b/packages/eslint-config-turbo/package.json @@ -1,6 +1,6 @@ { "name": "eslint-config-turbo", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "ESLint config for Turborepo", "repository": { "type": "git", diff --git a/packages/eslint-plugin-turbo/package.json b/packages/eslint-plugin-turbo/package.json index 7dead7e158e28..cba9334f973f5 100644 --- a/packages/eslint-plugin-turbo/package.json +++ b/packages/eslint-plugin-turbo/package.json @@ -1,6 +1,6 @@ { "name": "eslint-plugin-turbo", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "ESLint plugin for Turborepo", "keywords": [ "turbo", diff --git a/packages/turbo-codemod/package.json b/packages/turbo-codemod/package.json index 24164076a111d..4fb85dde24231 100644 --- a/packages/turbo-codemod/package.json +++ b/packages/turbo-codemod/package.json @@ -1,6 +1,6 @@ { "name": "@turbo/codemod", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "Provides Codemod transformations to help upgrade your Turborepo codebase when a feature is deprecated.", "homepage": "https://turbo.build/repo", "license": "MIT", diff --git a/packages/turbo-gen/package.json b/packages/turbo-gen/package.json index a2bcdd511dbf5..d4819d86709db 100644 --- a/packages/turbo-gen/package.json +++ b/packages/turbo-gen/package.json @@ -1,6 +1,6 @@ { "name": "@turbo/gen", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "Extend a Turborepo", "homepage": "https://turbo.build/repo", "license": "MIT", diff --git a/packages/turbo-ignore/package.json b/packages/turbo-ignore/package.json index 92a191591842d..c46bee7337154 100644 --- a/packages/turbo-ignore/package.json +++ b/packages/turbo-ignore/package.json @@ -1,6 +1,6 @@ { "name": "turbo-ignore", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "", "homepage": "https://turbo.build/repo", "keywords": [], diff --git a/packages/turbo-types/package.json b/packages/turbo-types/package.json index d1854816e6f6e..e7c62bee10e55 100644 --- a/packages/turbo-types/package.json +++ b/packages/turbo-types/package.json @@ -1,6 +1,6 @@ { "name": "@turbo/types", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "Turborepo types", "homepage": "https://turbo.build/repo", "license": "MIT", diff --git a/packages/turbo-workspaces/package.json b/packages/turbo-workspaces/package.json index 5f41ae25c9f1f..18970adb53097 100644 --- a/packages/turbo-workspaces/package.json +++ b/packages/turbo-workspaces/package.json @@ -1,6 +1,6 @@ { "name": "@turbo/workspaces", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "Tools for working with package managers", "homepage": "https://turbo.build/repo", "license": "MIT", diff --git a/packages/turbo/package.json b/packages/turbo/package.json index e5e919b984cd0..99af55dd259c1 100644 --- a/packages/turbo/package.json +++ b/packages/turbo/package.json @@ -1,6 +1,6 @@ { "name": "turbo", - "version": "2.0.11", + "version": "2.0.12-canary.0", "description": "Turborepo is a high-performance build system for JavaScript and TypeScript codebases.", "repository": "https://github.com/vercel/turbo", "bugs": "https://github.com/vercel/turbo/issues", @@ -17,11 +17,11 @@ "bin" ], "optionalDependencies": { - "turbo-darwin-64": "2.0.11", - "turbo-darwin-arm64": "2.0.11", - "turbo-linux-64": "2.0.11", - "turbo-linux-arm64": "2.0.11", - "turbo-windows-64": "2.0.11", - "turbo-windows-arm64": "2.0.11" + "turbo-darwin-64": "2.0.12-canary.0", + "turbo-darwin-arm64": "2.0.12-canary.0", + "turbo-linux-64": "2.0.12-canary.0", + "turbo-linux-arm64": "2.0.12-canary.0", + "turbo-windows-64": "2.0.12-canary.0", + "turbo-windows-arm64": "2.0.12-canary.0" } } diff --git a/version.txt b/version.txt index 8ec809b74a14e..06e0a1db50a6f 100644 --- a/version.txt +++ b/version.txt @@ -1,2 +1,2 @@ -2.0.11 -latest +2.0.12-canary.0 +canary