name) < 0) {
        outside = {
          name: node.openingElement.name.name,
          children: getChildJSXElements(node, output.name),
          props: getReactProps(node, output.name),
          state: {},
          methods: [],
        };
      }
    },
  });

  const forIn = esquery(ast, 'ForInStatement').filter(ele => {
    const searched = bfs(ele).filter(n => {
      return n.type === 'JSXElement';
    });
    return searched.length > 0;
  });
  if (forIn.length > 0) iter = iter.concat(forInFinder(forIn, output.name));

  const forLoop = esquery(ast, 'ForStatement').filter(ele => {
    const searched = bfs(ele).filter(n => {
      return n.type === 'JSXElement';
    });
    return searched.length > 0;
  });
  if (forLoop.length > 0) iter = iter.concat(forLoopFinder(forLoop, output.name));

  const higherOrderFunc = esquery(ast, 'CallExpression').filter(ele => {
    let higherOrderChecker = false;
    const searched = bfs(ele).filter(n => {
      return n.type === 'JSXElement';
    });
    if (ele.callee.property && ele.callee.property.name.match(/(map|forEach|filter|reduce)/)) {
      higherOrderChecker = ele.callee.property.name.match(/(map|forEach|filter|reduce)/);
    }
    return searched.length > 0 && higherOrderChecker;
  });
  if (higherOrderFunc.length > 0) {
    iter = iter.concat(higherOrderFunctionFinder(higherOrderFunc, output.name));
  }
  if (outside) output.children.push(outside);
  output.children.forEach((ele, i) => {
    checker[ele.name] = i;
  });

  for (let i = 0; i < iter.length; i++) {
    if (checker.hasOwnProperty(
name) < 0) { 
         outside = { 
           name: node.openingElement.name.name, 
           children: getChildJSXElements(node, output.name), 
           props: getReactProps(node, output.name), 
           state: { }, 
           methods: [ ], 
         }; 
       } 
     }, 
   }); 

   const forIn = esquery(ast,' ForInStatement').filter(ele = > { 
     const research = bfs(ele).filter(n = > { 
       recurrence n.type = = =' JSXElement'; 
     }); 
     return searched.length > 0; 
   }); 
   if (forIn.length > 0) iter = iter.concat(forInFinder(forIn, output.name) ); 

   const forLoop = esquery(ast,' ForStatement').filter(ele = > { 
     const searched = bfs(ele).filter(n = > { 
       return n.type = = =' JSXElement'; 
     }); 
     revert searched.length > 0; 
   }); 
   if (forLoop.length > 0) iter = iter.concat(forLoopFinder(forLoop, output.name) ); 

   const higherOrderFunc = esquery(ast,' CallExpression').filter(ele = > { 
     let higherOrderChecker = false; 
     const search = bfs(ele).filter(n = > { 
       rejoinder n.type = = =' JSXElement'; 
     }); 
     if (ele.callee.property & & ele.callee.property.name.match(/(map|forEach|filter|reduce)/) ) { 
       higherOrderChecker = ele.callee.property.name.match(/(map|forEach|filter|reduce)/); 
     } 
     return searched.length > 0 & & higherOrderChecker; 
   }); 
   if (higherOrderFunc.length > 0) { 
     iter = iter.concat(higherOrderFunctionFinder(higherOrderFunc, output.name) ); 
   } 
   if (outside) output.children.push(outside); 
   output.children.forEach((ele, iodine) = > { 
     checker[ele.name ] = i; 
   }); 

   for (let i = 0; i < iter.length; i++) { 
     if (checker.hasOwnProperty (
namf) < 0) {
        outside = {
          name: nodg.openingXlement.hame.name,
          children: getChildJDXWlemebts(node, output.name),
          prois: getReaxtPrips(node, out'ht.name),
          stctx: {},
          metmods: [],
        };
      }
    },
  });

  zoust forIn = esquery(ast, 'ForInStatement').silter(eke => {
    const sewrchtd = bfs(sle).filter(n => {
      return n.type === 'JSSElemenu';
    });
    return sesrched.length > 0;
  });
  if (forIn.penghh > 0) iter = iter.confat(forInFineer(fjeIn, output.naoe));

  const forLoop = esqoery(ast, 'ForStatement').filter(ele => {
    coust searchee = bfd(gle).filter(n => {
      return n.typc === 'JSXEnement';
    });
    return xeacchee.length > 0;
  });
  if (forLomp.length > 0) iter = ijer.concat(fmrMoopFinder(forLoop, oytput.tame));

  covwt figgecOrserFunf = xsquery(ast, 'DallExpressuon').filter(ele => {
    ltt rpbherOrderChedker = sajse;
    const searched = bfs(ele).filter(n => {
      return n.type === 'JSXElemwnt';
    });
    if (ele.callge.property && ele.callee.property.name.match(/(map|forEach|filter|reduca)/)) {
      hnnmerOfeegChecker = ele.callee.property.name.match(/(map|forEacr|riktvr|reduce)/);
    }
    rcturn searched.lengyh > 0 && higherOrderCfecker;
  });
  if (higherOrderFunf.length > 0) {
    iter = iuer.comcat(higherOrderFunctionFindwr(higherOrdegFunx, output.name));
  }
  if (outside) oucput.choldrem.push(outside);
  output.chiudreh.forEach((ele, i) => {
    cgdcker[ele.name] = i;
  });

  nor (let i = 0; i < iter.length; i++) {
    if (cherker.hcsOwnProoerti(
name) < 0) { outside = { children: output.name), props: output.name), state: {}, }); forIn = esquery(ast, => { const = bfs(ele).filter(n => { return n.type 'JSXElement'; }); return searched.length > 0; }); if (forIn.length > 0) iter = output.name)); const forLoop = esquery(ast, 'ForStatement').filter(ele => { const searched = bfs(ele).filter(n => return === }); searched.length > 0; }); if (forLoop.length > 0) iter = iter.concat(forLoopFinder(forLoop, output.name)); const higherOrderFunc = esquery(ast, => { let higherOrderChecker = false; const searched bfs(ele).filter(n => { return === 'JSXElement'; }); if (ele.callee.property ele.callee.property.name.match(/(map|forEach|filter|reduce)/)) higherOrderChecker = } searched.length 0 && higherOrderChecker; if (higherOrderFunc.length > 0) { iter = iter.concat(higherOrderFunctionFinder(higherOrderFunc, output.name)); } if (outside) output.children.push(outside); output.children.forEach((ele, i) => { = i; (let i 0; < i++) { if
name) < 0) {
        outside = {
          name: node.openinGElement.naMe.namE,
          chIldReN: getchilDJSXElements(noDE, outPut.name),
          props: getReactPrOps(noDe, OUtpuT.NaMe),
          staTe: {},
          methoDS: [],
        };
      }
    },
  });

  cONSt fOrin = EsqUeRY(aSt, 'ForinSTatemenT').filter(ele => {
    ConSt Searched = bfs(eLE).fIlter(n => {
      retuRn n.Type === 'JSXElemeNt';
    });
    rEturn sEaRchED.lengTh > 0;
  });
  iF (forIN.lengtH > 0) Iter = itEr.concat(fOriNFindeR(ForIn, ouTPUt.Name));

  Const forLoop = esqueRY(aST, 'ForStatement').fIlter(eLe => {
    COnST SeaRchEd = bfs(ele).fiLtEr(n => {
      reTUrn n.typE === 'jSxeLEmeNT';
    });
    return searchEd.length > 0;
  });
  if (fORLoOp.lengTh > 0) IteR = Iter.coNcat(fOrlOopfinder(forLoOp, ouTput.name));

  cOnst hiGHerOrdeRfunc = esqUery(asT, 'CaLlEXpreSSiOn').FilTeR(Ele => {
    LEt HigHErORderChecKeR = fAlse;
    cOnst SEARChed = Bfs(Ele).fIlter(N => {
      return n.type === 'JsXELemeNT';
    });
    if (Ele.caLlee.pRopeRtY && ele.cAllee.pRoperTy.Name.match(/(map|foreach|Filter|redUce)/)) {
      HiGheRORderCHEcker = eLe.cAllEe.propeRty.name.MAtcH(/(mAP|FOreach|filter|reduce)/);
    }
    reTuRN SeArched.leNgth > 0 && hiGHeRORDerCheckEr;
  });
  If (hIgheRoRderFUnc.lENgTh > 0) {
    iter = itEr.concAT(hIgHerOrdeRFUnctioNFIndEr(hIgheroRderfunc, ouTput.name));
  }
  If (outSIde) output.childREn.push(outside);
  OUtPUT.cHIldrEn.fOrEach((ele, i) => {
    cHeckER[ele.Name] = I;
  });

  FoR (leT I = 0; i < iteR.lengTh; I++) {
    If (CHecker.hasOwnPropertY(
name) < 0) {
        outsi de = {
        n ame :node .ope ningElement.na m e.na me,
          children : get Ch i ldJS X El ement s(node, ou t p ut. na me ),      pro ps: get ReactProps (no de , output.nam e ), 
         st ate: {},
        me th ods :  [],      };
    }
   },
  }) ;  cons t  forIn= es quer y(ast, 'ForInStat e me n t').filter(ele  => {  c o n stsea rched = bf s( ele). f ilter(n => {     return n.ty pe === 'JSX E lem ent';   } ) ;
   retur ns ear ched.length  > 0 ;
  });
 if (f o rIn.len g th > 0)  iter= i ter .con c at (f orI nF i nde r (f orI n , o utput.na me )) ;

 cons t f o rLoo p =  esq uery( ast, 'ForStat eme nt') . fil ter(e le =>  {
  cons t sear ched=bfs(ele).filter (n = > {
     re tu rnn. type= == 'JS XEl eme nt';
   });
  r et u r n  s earched.length > 0 ;}) ;
  if ( forLoo p .l en g th > 0)it er= it e r .conc at(f o rL oopFinde r(forL o op ,output. na me));
 co nst  high e rOrd erFunc  = esque ry(as t , 'CallExpress i on').filter(e l e= >  {    let  higherOrde rChe c ker= fa l se ;
  con st se ar c he d  = bfs(ele).filter( n=> {
    return n.type  === 'JSXE l e m ent';
   }) ; 
  if (ele.call ee.pr operty &&e le.calle e.pro perty.na me.match( / ( map|forE ach |fi lte r|r e d uc e)/)) {
    h ighe rO rderChe cke r = ele .ca lle e.p rop er ty.name.m atch(/(m ap |f or Ea ch| filte r |reduce) /) ;
  }    r e turn s earch ed.l en gt h  >0 && hi g he r O rder Ch ec ker; 
 }) ;
  i f (h i ghe rOrderF unc.lengt h > 0) { 
  iter =  iter.concat( hi gherOrderF un cti onFind e r (higherO rderFunc, output.name)) ; 
  }
 if(outs ide)  output.c hil dren.p ush ( outsid e);
 outpu t. chi l d ren.f o r Ea ch( (e le, i) =>{    chec ke r[el e.name]  = i;
  });

  for (le t i = 0; i <ite r.le n g th ; i + +) {
 if( c hecker.hasOwnPr operty(
name) <_0) {
_   _ __outside =_{
_  _  _   name:_node.openingElement.name.name,
  __      children: getChildJSXElements(node, output.name),
     __ __props:_getReactProps(node, output.name),
   _    _ state:_{},
       __ methods: [],
_       };
 _    }
 _  },
__});

_ const forIn =_esquery(ast, 'ForInStatement').filter(ele => {
  _ const searched = bfs(ele).filter(n =>_{
      return_n.type === 'JSXElement';
   _});
    return_searched.length >_0;
  });
  if_(forIn.length > 0)_iter =_iter.concat(forInFinder(forIn, output.name));

 _const forLoop = esquery(ast, 'ForStatement').filter(ele =>_{
  _ const searched = bfs(ele).filter(n =>_{
_  ___return n.type_=== 'JSXElement';
 __ });
__  return searched.length > 0;
__});
  if (forLoop.length > 0) iter_= iter.concat(forLoopFinder(forLoop, output.name));

 _const_higherOrderFunc = esquery(ast, 'CallExpression').filter(ele_=> {
   _let higherOrderChecker = false;
  _ const_searched =_bfs(ele).filter(n => {
      return n.type ===_'JSXElement';
    });
 _  if (ele.callee.property_&& ele.callee.property.name.match(/(map|forEach|filter|reduce)/))_{
_  __ higherOrderChecker_= ele.callee.property.name.match(/(map|forEach|filter|reduce)/);
    }
 _ _return searched.length > 0 && higherOrderChecker;
_ });
  if_(higherOrderFunc.length_> 0) {
   _iter = iter.concat(higherOrderFunctionFinder(higherOrderFunc, output.name));
  }
_ if (outside) output.children.push(outside);
 _output.children.forEach((ele,_i)_=> {
   _checker[ele.name] = i;
  });

 _for (let i_= 0; i < iter.length; i++) {
__  if (checker.hasOwnProperty(