{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-markus/src/components/widgets/lively-code-mirror-ast-capabilities.js"],"names":["loc","range","fileEnding","replaceFileEndingWith","boundEval","FileIndex","babelDefault","babel","t","types","template","ASTCapabilities","constructor","codeProvider","codeChanged","selectionRanges","selections","length","firstSelection","map","_getFirstSelectionOrCursorPosition","anchor","cursor","head","programPath","myProgramPath","parsingFailed","programPathFor","sourceCode","code","traverseAsAST","Program","path","err","undefined","rootNode","parent","finishedEnrichment","memberAssignments","Map","aexprs","canParse","nextPath","startingPath","isValid","pathToShow","traverse","enter","stop","getLastPath","nextPathCallback","getFirstChildOrSelf","child","getPathBeforeCursor","selectionStart","foundPath","exit","pathLocation","node","pathEnd","end","isBefore","getInnermostPathContainingSelection","selection","nextPathContainingCursor","newStartingPath","containsRange","prevPath","getSelectedPaths","pathContainingWholeSelection","isPathExactlySelected","selectedPaths","containsPartsOfRange","push","skip","flat","getSelectedStatements","getOutermostPathContainingSelectionWithMinimalSelectionRange","isStatement","isBlockStatement","Statement","getSelectedExpressions","isExpression","isIdentifier","Expression","currentPath","findParent","isEqual","forwardList","parentPath","linearizedPathList","backwardList","reverse","selectNextASTNodeWith","condition","reversed","pathList","maxPaths","getNextASTNodeInListWith","selectPaths","getFirstSelectedIdentifier","startPath","first","Identifier","getFirstSelectedIdentifierWithName","name","getAllIdentifiers","identifiers","getDeclaration","identifier","scope","hasBinding","getBinding","getBindingDeclarationIdentifierPath","binding","getBindingsInFile","astBindings","getASTBinding","getClassBindings","identifierPaths","Set","referencePaths","constantViolations","cv","includes","isMemberExpression","isThisExpression","object","classPath","getClassPath","methodPath","getMethodPath","getClassMethodBindings","getMemberBindings","isClassMethod","classMethod","methodIdentifier","getUnbound","members","getAllUnboundIdentifierNames","unboundIdentifiers","filter","value","index","self","indexOf","currentPathInList","find","pathInList","currentIndex","i","selectNodes","nodes","selectStringContentsOnly","ranges","paths","ClassMethod","key","FunctionDeclaration","id","ClassDeclaration","getColorLiterals","pPath","colorPaths","colorRegex","StringLiteral","match","expandSelection","strictlyContainsRange","reduceSelection","selectNextASTChild","currentNode","nextNode","isLiteral","isSuper","isDebuggerStatement","selectNextASTNodeLikeThis","type","selectNextReference","selectedPath","bindings","sortedBindings","sort","a","b","start","selectDeclaration","identName","declaration","isImportSpecifier","classUrls","getCorrespondingClasses","then","arr","cl","url","functionUrls","getFunctionExportURLs","urls","concat","forEach","lively","openBrowser","container","asyncGet","livelyEditor","newCodeMirror","livelyCodeMirror","cm","awaitEditor","astCapabilities","ac","rename","bindingItems","getPossibleBindingsAcrossFiles","comp","openComponentInWindow","focus","setAdditionalInput","setTitle","references","selectItems","newName","getAdditionalInput","camelCase","reference","fetch","r","text","codeLines","split","String","prototype","replaceBetween","what","substring","line","ch","newCode","join","files","saveFile","reloadModule","System","import","selectBindings","printAllBindings","openReferencesMenu","current","ids","db","file","some","toArray","program","column","lastIndexOf","identifierName","findImports","functions","classes","isInDescribe","possiblePath","isIn","callee","isDirectlyIn","Array","elem","reduce","accu","updateColor","currentLocation","color","location","scrollInfo","transformAsAST","visitor","isStringLiteral","scrollTo","openHTMLAccessorsMenu","initialSelectionState","getExistingAccessors","classMethodIdentifier","ExportDefaultDeclaration","body","generateHTMLAccessors","compileListOfIDs","existingMethods","generateMethodNameFromProperty","selectedItems","warn","item","generateCodeFragment","compileHTMLGetter","htmlURI","html","fetchText","tmp","innerHTML","childNodes","content","querySelectorAll","ea","htmlLines","idsWithLocation","indexOfId","generateTestCase","compileTestCase","generateGetter","compileGetter","generateSetter","compileSetter","generateClass","compileClass","replacementGenerator","identifierObject","generatedCode","pathBefore","pathWithin","unshiftContainer","insertAfter","pathToSelect","explanation","EXP","stringLiteral","propertyName","blockStatement","returnStatement","memberExpression","thisExpression","expressionStatement","assignmentExpression","className","classDeclaration","classBody","property","methodName","callExpression","getUserInput","description","defaultValue","input","prompt","Promise","resolve","reject","addImport","importName","isFunction","existingImportStatement","isImportDeclaration","source","importStatement","importDeclaration","importSpecifier","unshift","specifiers","spec","imported","replaceWith","findParameters","surroundingMethod","actualSelections","needsToBeParameter","bindingPath","isSelected","shouldBeAsync","hasAwait","isAwaitExpression","AwaitExpression","couldBeStatic","hasThis","ThisExpression","findReturnValues","declarationInSelection","constantViolationInSelection","constantViolation","referenceOutsideSelection","needsToBeReturned","constantViolationOutsideSelection","declaredInExtractedCode","createMethod","parameter","returnValues","extractingExpression","shouldBeStatic","returnValue","returnIdentifier","objectExpression","objectProperty","methodContent","p","newMethod","async","static","remove","methodCall","awaitExpression","variableType","variableDeclaration","variableDeclarator","objectPattern","replaceWithMultiple","extractMethod","transformed","selectMethodExtraction","parameters","pathsToSelect","silent","expressions","extractExpressionIntoLocalVariable","done","pathLocationToBeExtracted","res","isSelectedPath","getPathLocation","ensureBlock","statements","blockNode","isArrowFunctionExpression","Error","targetLocation","blockLocation","parentKey","isFor","isWhile","becameABlock","replace","isIfStatement","pathLocationsToSelect","resultExtracted","pathByLocationFromProgram","generateUidIdentifier","decl","ID","INIT","referree","insertedDeclaration","getStatementParent","insertBefore","insertedDeclarationIdentifier","get","pathLocationsToPathes","wrapExpressionIntoActiveExpression","ae","EXPR","expression","pathRange","reg","result","exec","part","startsWith","parseInt","pathLocations","possibleClasses","methods","me","possibleExports","exports","where","anyOf","locations","e","eCl","lively4url","exp","getAexprAtCursor","aexprPath","CallExpression","contains","isAExpr","hasActiveExpressionsDirective","directives","ensureEnrichment","enrich","console","error","extra","visited","returnVisited","Scope","Object","entries","_name","extractMemberAssignments","enrichFunctionNodes","expr","collectExpressionInformation","MemberExpression","computed","isAssignmentExpression","assignment","assignedValue","obj","objKey","entry","newMap","set","objEntry","leakingBindings","callExpressions","objects","returns","objExpr","add","ReturnStatement","ret","has","call","results","resolvedObjects","isObjectExpression","isUpdateExpression","isVariableDeclarator","val","isConditionalExpression","isCallExpression","resolvedCallees","func","assignmentsOf","shadowedBindings","propertyEntry","memberDependencies","isObjectProperty","isObjectMethod","isFunctionDeclaration","isPattern","resolveDependencies","dependencies","_resolveDependencies","dep","size","member","getAllActiveExpressions","_collectAExprs","allAExpr","AEXPR_IDENTIFIER_NAME","ReferencedIdentifier","outerBinding","actualBinding"],"mappings":";;;;;;;;;;;AAASA,S,UAAAA,G;AAAKC,W,UAAAA,K;AAWLC,gB,UAAAA,U;AAAYC,2B,UAAAA,qB;;AATdC,e;;AACAC,e;;AAEAC,kB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACP,YAAMC,QAAQD,aAAaC,KAA3B;;;;;;;;;;;;;;;AAEA,YAAMC,IAAID,MAAME,KAAhB;;;;;;;;;;;;;;AACA,YAAMC,WAAWH,MAAMG,QAAvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIe,YAAMC,eAAN,CAAsB;;AAEnCC,oBAAYC,YAAZ,EAA0B;AACxB,eAAKA,YAAL,GAAoBA,YAApB;AACA,eAAKC,WAAL;AACD;;AAED,YAAIC,eAAJ,GAAsB;AACpB,cAAI,KAAKF,YAAL,CAAkBG,UAAlB,CAA6BC,MAA7B,IAAuC,CAA3C,EAA8C;AAC5C,mBAAO,KAAKC,cAAZ;AACD;AACD,iBAAO,KAAKL,YAAL,CAAkBG,UAAlB,CAA6BG,GAA7B,CAAiClB,KAAjC,CAAP;AACD;;AAED,YAAIiB,cAAJ,GAAqB;AACnB,iBAAOjB,MAAM,KAAKmB,kCAAL,EAAN,CAAP;AACD;;AAEDA,6CAAqC;AACnC,cAAI,KAAKP,YAAL,CAAkBG,UAAlB,CAA6BC,MAA7B,IAAuC,CAA3C,EAA8C;AAC5C,mBAAO,EAAEI,QAAQ,KAAKR,YAAL,CAAkBS,MAA5B,EAAoCC,MAAM,KAAKV,YAAL,CAAkBS,MAA5D,EAAP;AACD;AACD,iBAAO,KAAKT,YAAL,CAAkBG,UAAlB,CAA6B,CAA7B,CAAP;AACD;;AAED;AACA;;;AAGA,YAAIQ,WAAJ,GAAkB;AAChB,cAAI,CAAC,KAAKC,aAAN,IAAuB,CAAC,KAAKC,aAAjC,EAAgD;AAC9C,iBAAKD,aAAL,GAAqB,KAAKE,cAAL,CAAoB,KAAKC,UAAzB,CAArB;AACA,iBAAKF,aAAL,GAAqB,CAAC,KAAKD,aAA3B;AACD;AACD,iBAAO,KAAKA,aAAZ;AACD;;AAEDE,uBAAeE,IAAf,EAAqB;AACnB,cAAIL,cAAc,IAAlB;AACA,cAAI;AACFK,iBAAKC,aAAL,CAAmB;AACjBC,sBAAQC,IAAR,EAAc;AACZR,8BAAcQ,IAAd;AACD;AAHgB,aAAnB;AAKD,WAND,CAME,OAAOC,GAAP,EAAY;AACZ,mBAAOC,SAAP;AACD;;AAED,iBAAOV,WAAP;AACD;;AAED,YAAIW,QAAJ,GAAe;AACb,iBAAO,KAAKX,WAAL,IAAoB,KAAKA,WAAL,CAAiBY,MAA5C;AACD;;AAEDtB,sBAAc;AACZ,eAAKW,aAAL,GAAqBS,SAArB;AACA,eAAKR,aAAL,GAAqB,IAArB;AACA,eAAKW,kBAAL,GAA0B,KAA1B;AACA,eAAKC,iBAAL,GAAyB,IAAIC,GAAJ,EAAzB;AACA,eAAKC,MAAL,GAAcN,SAAd;AACD;;AAED,YAAIO,QAAJ,GAAe;AACb,cAAI,KAAKf,aAAL,IAAsB,IAA1B,EAAgC,KAAKF,WAAL;AAChC,iBAAO,CAAC,KAAKE,aAAb;AACD;;AAED;;;AAGAgB,iBAASC,YAAT,EAAuBC,OAAvB,EAAgC;AAC9B,cAAIC,UAAJ;;AAEAF,uBAAaG,QAAb,CAAsB;AACpBC,kBAAMf,IAAN,EAAY;AACV,kBAAI,CAACa,UAAD,IAAeD,QAAQZ,IAAR,CAAnB,EAAkC;AAChCa,6BAAab,IAAb;AACAA,qBAAKgB,IAAL;AACD;AACF;AANmB,WAAtB;;AASA,iBAAOH,UAAP;AACD;;AAED;;;AAGAI,oBAAYN,YAAZ,EAA0BO,gBAA1B,EAA4C;AAC1C,cAAIL,aAAaF,YAAjB;AACA,iBAAO,IAAP,EAAa;AACX,gBAAID,WAAWQ,iBAAiBL,UAAjB,CAAf;AACA,gBAAIH,QAAJ,EAAc;AACZG,2BAAaH,QAAb;AACD,aAFD,MAEO;AACL;AACD;AACF;;AAED,iBAAOG,UAAP;AACD;;AAED;;;AAGAM,4BAAoBR,YAApB,EAAkC;AAChC,cAAIS,KAAJ;AACAT,uBAAaG,QAAb,CAAsB;AACpBC,kBAAMf,IAAN,EAAY;AACV,kBAAI,CAACoB,KAAL,EAAY;AACVA,wBAAQpB,IAAR;AACD;AACF;AALmB,WAAtB;AAOA,iBAAOoB,SAAST,YAAhB;AACD;;AAED;;;AAGAU,4BAAoBV,YAApB,EAAkCtB,MAAlC,EAA0C;AACxC,gBAAMiC,iBAAiBtD,IAAIqB,MAAJ,CAAvB;AACA,cAAIkC,SAAJ;AACAZ,uBAAaG,QAAb,CAAsB;AACpBU,iBAAKxB,IAAL,EAAW;AACT,oBAAMyB,eAAezB,KAAK0B,IAAL,CAAU1D,GAA/B;AACA,oBAAM2D,UAAU3D,IAAIyD,aAAaG,GAAjB,CAAhB;AACA,kBAAIN,eAAeO,QAAf,CAAwBF,OAAxB,CAAJ,EAAsC;AACpC3B,qBAAKgB,IAAL;AACA;AACD;AACDO,0BAAYvB,IAAZ;AACD;AATmB,WAAtB;AAWA,iBAAOuB,SAAP;AACD;;AAED;;;AAGAO,4CAAoCnB,YAApC,EAAkDoB,SAAlD,EAA6D;AAC3D;AACA,gBAAMC,2BAA2B,CAACC,eAAD,EAAkBF,SAAlB,KAAgC;AAC/D,mBAAO,KAAKrB,QAAL,CAAcuB,eAAd,EAA+BjC,QAAQ;AAC5C,qBAAO/B,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,EAAqBkE,aAArB,CAAmCH,SAAnC,CAAP;AACD,aAFM,CAAP;AAGD,WAJD;AAKA,iBAAO,KAAKd,WAAL,CAAiBN,YAAjB,EAA+BwB,YAAYH,yBAAyBG,QAAzB,EAAmCJ,SAAnC,CAA3C,CAAP;AACD;;AAEDK,yBAAiB5C,WAAjB,EAA8B;AAC5B,iBAAO,KAAKT,eAAL,CAAqBI,GAArB,CAAyB4C,aAAa;AAC3C,kBAAMM,+BAA+B,KAAKP,mCAAL,CAAyCtC,WAAzC,EAAsDuC,SAAtD,CAArC;;AAEA;AACA,gBAAI,KAAKO,qBAAL,CAA2BD,4BAA3B,EAAyDN,SAAzD,CAAJ,EAAyE;AACvE,qBAAOM,4BAAP;AACD;;AAED;AACA,gBAAIE,gBAAgB,EAApB;AACAF,yCAA6BvB,QAA7B,CAAsC;AACpCC,oBAAMf,IAAN,EAAY;AACV,oBAAI+B,UAAUS,oBAAV,CAA+BvE,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAA/B,CAAJ,EAA0D;AACxDuE,gCAAcE,IAAd,CAAmBzC,IAAnB;AACD;AACDA,qBAAK0C,IAAL;AACD;AANmC,aAAtC;AAQA,mBAAOH,aAAP;AACD,WAnBM,EAmBJI,IAnBI,EAAP;AAoBD;;AAEDC,8BAAsBpD,WAAtB,EAAmC;AACjC,iBAAO,KAAKT,eAAL,CAAqBI,GAArB,CAAyB4C,aAAa;AAC3C;AACA,kBAAMM,+BAA+B,KAAKQ,4DAAL,CAAkErD,WAAlE,EAA+EuC,SAA/E,CAArC;;AAEA,gBAAIvD,EAAEsE,WAAF,CAAcT,4BAAd,KAA+C,CAAC7D,EAAEuE,gBAAF,CAAmBV,4BAAnB,CAApD,EAAsG;AACpG,qBAAOA,4BAAP;AACD;;AAED;AACA,gBAAIE,gBAAgB,EAApB;AACAF,yCAA6BvB,QAA7B,CAAsC;AACpCkC,wBAAUhD,IAAV,EAAgB;AACd,oBAAI+B,UAAUS,oBAAV,CAA+BvE,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAA/B,CAAJ,EAA0D;AACxDuE,gCAAcE,IAAd,CAAmBzC,IAAnB;AACD;AACDA,qBAAK0C,IAAL;AACD;AANmC,aAAtC;AAQA,mBAAOH,aAAP;AACD,WAnBM,EAmBJI,IAnBI,EAAP;AAoBD;;AAEDM,+BAAuBzD,WAAvB,EAAoC;AAClC,iBAAO,KAAKT,eAAL,CAAqBI,GAArB,CAAyB4C,aAAa;AAC3C;AACA,kBAAMM,+BAA+B,KAAKQ,4DAAL,CAAkErD,WAAlE,EAA+EuC,SAA/E,CAArC;;AAEA,gBAAIvD,EAAE0E,YAAF,CAAeb,4BAAf,KAAgD,CAAC7D,EAAE2E,YAAF,CAAed,4BAAf,CAArD,EAAmG;AACjG,qBAAOA,4BAAP;AACD;AACD;AACA,gBAAIE,gBAAgB,EAApB;AACAF,yCAA6BvB,QAA7B,CAAsC;AACpCsC,yBAAWpD,IAAX,EAAiB;AACf,oBAAI+B,UAAUS,oBAAV,CAA+BvE,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAA/B,KAAwD,CAACQ,EAAE2E,YAAF,CAAenD,IAAf,CAA7D,EAAmF;AACjFuC,gCAAcE,IAAd,CAAmBzC,IAAnB;AACD;AACDA,qBAAK0C,IAAL;AACD;AANmC,aAAtC;AAQA,mBAAOH,aAAP;AACD,WAlBM,EAkBJI,IAlBI,EAAP;AAmBD;;AAED;;;;;;;;;AASAE,qEAA6DlC,YAA7D,EAA2EoB,SAA3E,EAAsF;AACpF,cAAIsB,cAAc,KAAKvB,mCAAL,CAAyCnB,YAAzC,EAAuDoB,SAAvD,CAAlB;AACAsB,sBAAYC,UAAZ,CAAuBtD,QAAQ;AAC7B,gBAAI+B,UAAUwB,OAAV,CAAkBtF,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAAlB,CAAJ,EAA6C;AAC3CqF,4BAAcrD,IAAd;AACD;AACD,mBAAO,KAAP;AACD,WALD;AAMA,iBAAOqD,WAAP;AACD;;AAED;;;AAGAG,oBAAYC,UAAZ,EAAwB;AACtB,gBAAMC,qBAAqB,EAA3B;AACAD,qBAAW3C,QAAX,CAAoB;AAClBU,iBAAKxB,IAAL,EAAW;AACT0D,iCAAmBjB,IAAnB,CAAwBzC,IAAxB;AACD;AAHiB,WAApB;AAKA,iBAAO0D,kBAAP;AACD;AACD;;;AAGAC,qBAAaF,UAAb,EAAyB;AACvB,gBAAMC,qBAAqB,EAA3B;AACAD,qBAAW3C,QAAX,CAAoB;AAClBC,kBAAMf,IAAN,EAAY;AACV0D,iCAAmBjB,IAAnB,CAAwBzC,IAAxB;AACD;AAHiB,WAApB;AAKA,iBAAO0D,mBAAmBE,OAAnB,EAAP;AACD;AACD;;;;AAIAC,8BAAsBC,SAAtB,EAAiCC,QAAjC,EAA2C;AACzC,gBAAMvE,cAAc,KAAKA,WAAzB;AACA,gBAAMwE,WAAWD,WAAW,KAAKJ,YAAL,CAAkBnE,WAAlB,CAAX,GAA4C,KAAKgE,WAAL,CAAiBhE,WAAjB,CAA7D;;AAEA,gBAAMyE,WAAW,KAAKlF,eAAL,CAAqBI,GAArB,CAAyB4C,aAAa;;AAErD,kBAAMsB,cAAc,KAAKR,4DAAL,CAAkErD,WAAlE,EAA+EuC,SAA/E,CAApB;;AAEA;AACA,gBAAIA,UAAUwB,OAAV,CAAkBtF,MAAMoF,YAAY3B,IAAZ,CAAiB1D,GAAvB,CAAlB,CAAJ,EAAoD;AAClD,qBAAO,KAAKkG,wBAAL,CAA8BJ,SAA9B,EAAyCE,QAAzC,EAAmDX,WAAnD,CAAP;AACD,aAFD,MAEO;AACL,qBAAOA,WAAP;AACD;AACF,WAVgB,CAAjB;;AAYA,eAAKc,WAAL,CAAiBF,QAAjB;AACD;;AAEDG,mCAA2BC,SAA3B,EAAsC;AACpC,cAAI7F,EAAE2E,YAAF,CAAekB,UAAU3C,IAAzB,CAAJ,EAAoC;AAClC,mBAAO2C,SAAP;AACD;AACD,cAAIC,KAAJ;AACAD,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWvE,IAAX,EAAiB;AACf,kBAAI,CAACsE,KAAL,EAAY;AACVA,wBAAQtE,IAAR;AACAA,qBAAKgB,IAAL;AACD;AACF;AANgB,WAAnB;AAQA,iBAAOsD,KAAP;AACD;;AAEDE,2CAAmCH,SAAnC,EAA8CI,IAA9C,EAAoD;AAClD,cAAIjG,EAAE2E,YAAF,CAAekB,UAAU3C,IAAzB,EAA+B,EAAE+C,MAAMA,IAAR,EAA/B,CAAJ,EAAoD;AAClD,mBAAOJ,SAAP;AACD;AACD,cAAIC,KAAJ;AACAD,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWvE,IAAX,EAAiB;AACf,kBAAI,CAACsE,KAAD,IAAU9F,EAAE2E,YAAF,CAAenD,KAAK0B,IAApB,EAA0B,EAAE+C,MAAMA,IAAR,EAA1B,CAAd,EAAyD;AACvDH,wBAAQtE,IAAR;AACAA,qBAAKgB,IAAL;AACD;AACF;AANgB,WAAnB;AAQA,iBAAOsD,KAAP;AACD;;AAEDI,0BAAkBL,SAAlB,EAA6B;AAC3B,cAAIM,cAAc,EAAlB;AACA;;;AAGAN,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWvE,IAAX,EAAiB;AACf2E,0BAAYlC,IAAZ,CAAiBzC,IAAjB;AACD;AAHgB,WAAnB;AAKA,iBAAO2E,WAAP;AACD;;AAEDC,uBAAeC,UAAf,EAA2B;AACzB,cAAIA,WAAWC,KAAX,CAAiBC,UAAjB,CAA4BF,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAJ,EAAuD;AACrD,mBAAOI,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,EAAkDzE,IAAzD;AACD;AACF;;AAEDiF,4CAAoCC,OAApC,EAA6C;AAC3C,iBAAO,KAAKV,kCAAL,CAAwCU,QAAQlF,IAAhD,EAAsDkF,QAAQL,UAAR,CAAmBJ,IAAzE,CAAP;AACD;;AAEDU,0BAAkBd,SAAlB,EAA6B;AAC3B,cAAIQ,aAAa,KAAKT,0BAAL,CAAgCC,SAAhC,CAAjB;AACA,cAAI,CAACQ,UAAL,EAAiB,OAAO,EAAP;AACjB,gBAAMO,cAAc,KAAKC,aAAL,CAAmBR,UAAnB,CAApB;;AAEA,cAAGO,WAAH,EAAgB;AACd,mBAAOA,WAAP;AACD;;AAED,iBAAO,KAAKE,gBAAL,CAAsBT,UAAtB,CAAP;AACD;;AAEDQ,sBAAcR,UAAd,EAA0B;AACxB,cAAIA,WAAWC,KAAX,CAAiBC,UAAjB,CAA4BF,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAJ,EAAuD;AACrD,kBAAMS,UAAUL,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAhB;AACA,kBAAMc,kBAAkB,CAAC,GAAG,IAAIC,GAAJ,CAAQ,CAAC,KAAKP,mCAAL,CAAyCC,OAAzC,CAAD,EAAoD,GAAGA,QAAQO,cAA/D,EAA+E,GAAGP,QAAQQ,kBAAR,CAA2BvG,GAA3B,CAA+BwG,MAAM,KAAKnB,kCAAL,CAAwCmB,EAAxC,EAA4CT,QAAQL,UAAR,CAAmBJ,IAA/D,CAArC,CAAlF,CAAR,CAAJ,CAAxB;AACA,gBAAIc,gBAAgBK,QAAhB,CAAyBf,UAAzB,CAAJ,EAA0C;AACxC,qBAAOU,eAAP;AACD;AACF;AACD,iBAAOrF,SAAP;AACD;;AAEDoF,yBAAiBT,UAAjB,EAA6B;AAC3B,cAAIrG,EAAEqH,kBAAF,CAAqBhB,WAAWzE,MAAhC,CAAJ,EAA6C;AAC3C,gBAAI5B,EAAEsH,gBAAF,CAAmBjB,WAAWzE,MAAX,CAAkB2F,MAArC,CAAJ,EAAkD;AAChD,kBAAIC,YAAY,KAAKC,YAAL,CAAkB,KAAKzG,WAAvB,CAAhB;AACA,kBAAI0G,aAAa,KAAKC,aAAL,CAAmBH,SAAnB,EAA8BnB,WAAWnD,IAAX,CAAgB+C,IAA9C,CAAjB;AACA,kBAAIyB,UAAJ,EAAgB;AACd,uBAAO,KAAKE,sBAAL,CAA4BF,UAA5B,CAAP;AACD,eAFD,MAEO;AACL,uBAAO,KAAKG,iBAAL,CAAuBxB,UAAvB,CAAP;AACD;AACF;AACF,WAVD,MAUO,IAAIrG,EAAE8H,aAAF,CAAgBzB,WAAWzE,MAA3B,CAAJ,EAAwC;AAC7C,mBAAO,KAAKgG,sBAAL,CAA4BvB,WAAWpB,UAAvC,CAAP;AACD;AACF;;AAED2C,+BAAuBG,WAAvB,EAAoC;AAClC,cAAIC,gBAAJ;AACAD,sBAAYzF,QAAZ,CAAqB;AACnByD,uBAAWvE,IAAX,EAAiB;AACfA,mBAAKgB,IAAL;AACAwF,iCAAmBxG,IAAnB;AACD;AAJkB,WAArB;AAMA,iBAAO,CAACwG,gBAAD,EAAmB,GAAG,KAAKH,iBAAL,CAAuBG,gBAAvB,CAAtB,CAAP;AACD;;AAED;;;AAGAH,0BAAkBxB,UAAlB,EAA8B4B,aAAa,KAA3C,EAAkDpC,YAAY,KAAK7E,WAAnE,EAAgF;AAC9E,cAAIkH,UAAU,EAAd;AACArC,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWvE,IAAX,EAAiB;AACf,kBAAIxB,EAAEqH,kBAAF,CAAqB7F,KAAKI,MAA1B,KAAqCJ,KAAK0B,IAAL,CAAU+C,IAAV,KAAmBI,WAAWnD,IAAX,CAAgB+C,IAA5E,EAAkF;AAChF,oBAAIjG,EAAEsH,gBAAF,CAAmB9F,KAAKI,MAAL,CAAY2F,MAA/B,KAA0C,CAACU,UAA/C,EAA2D;AACzDC,0BAAQjE,IAAR,CAAazC,IAAb;AACD,iBAFD,MAEO,IAAIyG,UAAJ,EAAgB;AACrBC,0BAAQjE,IAAR,CAAazC,IAAb;AACD;AACF;AACF;AATgB,WAAnB;AAWA,iBAAO0G,OAAP;AACD;;AAEDC,qCAA6BtC,YAAY,KAAK7E,WAA9C,EAA2D;AACzD,cAAIoH,qBAAqB,EAAzB;AACAvC,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWvE,IAAX,EAAiB;AACf,kBAAIxB,EAAEqH,kBAAF,CAAqB7F,KAAKI,MAA1B,CAAJ,EAAuC;AACrC,oBAAI,CAAC5B,EAAEsH,gBAAF,CAAmB9F,KAAKI,MAAL,CAAY2F,MAA/B,CAAL,EAA6C;AAC3Ca,qCAAmBnE,IAAnB,CAAwBzC,IAAxB;AACD;AACF;AACF;AAPgB,WAAnB;AASA,iBAAO4G,mBAAmBzH,GAAnB,CAAuB+F,WAAWA,QAAQxD,IAAR,CAAa+C,IAA/C,EAAqDoC,MAArD,CAA4D,CAACC,KAAD,EAAQC,KAAR,EAAeC,IAAf,KAAwBA,KAAKC,OAAL,CAAaH,KAAb,MAAwBC,KAA5G,CAAP;AACD;;AAED7C,iCAAyBJ,SAAzB,EAAoCE,QAApC,EAA8ChE,IAA9C,EAAoD;AAClD,gBAAMkH,oBAAoBlD,SAASmD,IAAT,CAAcC,cAAcA,WAAW1F,IAAX,KAAoB1B,KAAK0B,IAArD,CAA1B;AACA,gBAAM2F,eAAerD,SAASiD,OAAT,CAAiBC,iBAAjB,CAArB;AACA,eAAK,IAAII,IAAID,eAAe,CAA5B,EAA+BC,IAAItD,SAAS/E,MAA5C,EAAoDqI,GAApD,EAAyD;AACvD,gBAAIxD,UAAU9D,IAAV,EAAgBgE,SAASsD,CAAT,CAAhB,CAAJ,EAAkC;AAChC,qBAAOtD,SAASsD,CAAT,CAAP;AACD;AACF;AACD,iBAAOtD,SAASA,SAAS/E,MAAT,GAAkB,CAA3B,CAAP;AACD;;AAED;;;AAGAsI,oBAAYC,KAAZ,EAAmBC,2BAA2B,KAA9C,EAAqD;AACnD,gBAAMC,SAASF,MAAMrI,GAAN,CAAUuC,QAAQzD,MAAMyD,KAAK1D,GAAX,CAAlB,CAAf;AACA,eAAKa,YAAL,CAAkBG,UAAlB,GAA+B0I,MAA/B;AACD;;AAED;;;AAGAvD,oBAAYwD,KAAZ,EAAmBF,2BAA2B,KAA9C,EAAqD;AACnD,eAAKF,WAAL,CAAiBI,MAAMxI,GAAN,CAAUa,QAAQA,KAAK0B,IAAvB,CAAjB,EAA+C+F,wBAA/C;AACD;;AAED;;;AAGAtB,sBAAc3G,WAAd,EAA2BiF,IAA3B,EAAiC;AAC/B,cAAIyB,UAAJ;AACA1G,sBAAYsB,QAAZ,CAAqB;AACnB8G,wBAAY5H,IAAZ,EAAkB;AAChB,kBAAI,CAACkG,UAAD,IAAelG,KAAK0B,IAAL,CAAUmG,GAAV,CAAcpD,IAAd,IAAsBA,IAAzC,EAA+C;AAC7CyB,6BAAalG,IAAb;AACD;AACF,aALkB;AAMnB8H,gCAAoB9H,IAApB,EAA0B;AACxB,kBAAI,CAACkG,UAAD,IAAelG,KAAK0B,IAAL,CAAUqG,EAAV,CAAatD,IAAb,IAAqBA,IAAxC,EAA8C;AAC5CyB,6BAAalG,IAAb;AACD;AACF;AAVkB,WAArB;AAYA,iBAAOkG,UAAP;AACD;;AAED;;;AAGAD,qBAAazG,WAAb,EAA0B;AACxB,cAAIwG,SAAJ;AACAxG,sBAAYsB,QAAZ,CAAqB;AACnBkH,6BAAiBhI,IAAjB,EAAuB;AACrB,kBAAI,CAACgG,SAAL,EAAgB;AACdA,4BAAYhG,IAAZ;AACD;AACF;AALkB,WAArB;AAOA,iBAAOgG,SAAP;AACD;;AAEDiC,2BAAmB;AACjB,cAAIC,QAAQ,KAAK1I,WAAjB;AACA,cAAG,CAAC0I,KAAJ,EAAW;AACX,cAAIC,aAAa,EAAjB;AACA,gBAAMC,aAAa,2BAAnB;AACAF,gBAAMpH,QAAN,CAAe;AACbuH,0BAAcrI,IAAd,EAAoB;AAClB,kBAAIA,KAAK0B,IAAL,CAAUoF,KAAV,CAAgBwB,KAAhB,CAAsBF,UAAtB,CAAJ,EAAuC;AACrCD,2BAAW1F,IAAX,CAAgBzC,IAAhB;AACD;AACF;AALY,WAAf;AAOA,iBAAOmI,UAAP;AACD;;AAED;;AAEAI,0BAAkB;AAChB,gBAAMtE,WAAW,KAAKlF,eAAL,CAAqBI,GAArB,CAAyB4C,aAAa;AACrD,kBAAMlB,aAAa,KAAKiB,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2DuC,SAA3D,CAAnB;;AAEA;AACA,mBAAOlB,WAAWsG,IAAX,CAAgBnH,QAAQ;AAC7B,qBAAO/B,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,EAAqBwK,qBAArB,CAA2CzG,SAA3C,CAAP;AACD,aAFM,KAEDlB,UAFN;AAGD,WAPgB,CAAjB;;AASA,eAAKsD,WAAL,CAAiBF,QAAjB;AACD;;AAEDwE,0BAAkB;AAChB,gBAAMxE,WAAW,KAAKlF,eAAL,CAAqBI,GAArB,CAAyB4C,aAAa;AACrD,kBAAMlB,aAAa,KAAKiB,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2DuC,SAA3D,CAAnB;;AAEA,mBAAO,KAAKZ,mBAAL,CAAyBN,UAAzB,CAAP;AACD,WAJgB,CAAjB;;AAMA,eAAKsD,WAAL,CAAiBF,QAAjB;AACD;;AAEDyE,2BAAmB3E,QAAnB,EAA6B;AAC3B,iBAAO,KAAKF,qBAAL,CAA2B,CAAC8E,WAAD,EAAcC,QAAd,KAA2B;AAC3D,mBAAOpK,EAAE2E,YAAF,CAAeyF,QAAf,KAA4BpK,EAAEqK,SAAF,CAAYD,QAAZ,CAA5B,IAAqDpK,EAAEsH,gBAAF,CAAmB8C,QAAnB,CAArD,IAAqFpK,EAAEsK,OAAF,CAAUF,QAAV,CAArF,IAA4GpK,EAAEuK,mBAAF,CAAsBH,QAAtB,CAAnH;AACD,WAFM,EAEJ7E,QAFI,CAAP;AAGD;;AAEDiF,kCAA0BjF,QAA1B,EAAoC;AAClC,iBAAO,KAAKF,qBAAL,CAA2B,CAAC8E,WAAD,EAAcC,QAAd,KAA2BD,YAAYM,IAAZ,IAAoBL,SAASK,IAAnF,EAAyFlF,QAAzF,CAAP;AACD;;AAEDmF,4BAAoBnF,QAApB,EAA8B;AAC5B,gBAAMoF,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA,gBAAMkK,WAAW,KAAKjE,iBAAL,CAAuBgE,YAAvB,CAAjB,CAAsD,IAAIC,QAAJ,EAAc;AAClE,gBAAIC,iBAAiB,CAAC,GAAGD,QAAJ,EAAcE,IAAd,CAAmB,CAACC,CAAD,EAAIC,CAAJ,KAAUD,EAAE7H,IAAF,CAAO+H,KAAP,GAAeD,EAAE9H,IAAF,CAAO+H,KAAnD,CAArB;AACA,gBAAI1C,QAAQsC,eAAepC,OAAf,CAAuBkC,YAAvB,CAAZ;AACApC,qBAAShD,WAAW,CAAC,CAAZ,GAAgB,CAAzB;AACAgD,oBAAQ,CAACA,QAAQsC,eAAepK,MAAxB,IAAkCoK,eAAepK,MAAzD;AACA,iBAAKkF,WAAL,CAAiB,CAACkF,eAAetC,KAAf,CAAD,CAAjB;AACD;AACF;;AAED,cAAM2C,iBAAN,GAA0B;AACxB,gBAAMP,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;AACA,gBAAM2F,aAAa,KAAKT,0BAAL,CAAgC+E,YAAhC,CAAnB;AACA,cAAI,CAACtE,UAAL,EAAiB;AACf;AACD;AACD,gBAAM8E,YAAY9E,WAAWnD,IAAX,CAAgB+C,IAAlC;;AAEA,gBAAMmF,cAAc,MAAM,KAAKhF,cAAL,CAAoBC,UAApB,CAA1B;AACA;AACA,cAAI+E,eAAe,CAACpL,EAAEqL,iBAAF,CAAoBD,WAApB,CAApB,EAAsD;AACpD,iBAAKzF,WAAL,CAAiB,CAACyF,WAAD,CAAjB;AACD,WAFD,MAEO;AACL,gBAAI5D,YAAY,KAAKC,YAAL,CAAkB,KAAKzG,WAAvB,CAAhB;AACA,gBAAI0G,aAAa,KAAKC,aAAL,CAAmBH,SAAnB,EAA8B2D,SAA9B,CAAjB;AACA,gBAAIzD,UAAJ,EAAgB;AACd,mBAAKqB,WAAL,CAAiB,CAACrB,WAAWxE,IAAX,CAAgBmG,GAAjB,CAAjB;AACD,aAFD,MAEO;AACL,oBAAMiC,YAAY,MAAM,KAAKC,uBAAL,CAA6BJ,SAA7B,EAAwCK,IAAxC,CAA6CC,OAAOA,IAAI9K,GAAJ,CAAQ+K,MAAMA,GAAGC,GAAjB,CAApD,CAAxB;AACA,oBAAMC,eAAe,MAAM,KAAKC,qBAAL,CAA2BV,SAA3B,CAA3B;AACA,oBAAMW,OAAOR,UAAUS,MAAV,CAAiBH,YAAjB,CAAb;;AAEAE,mBAAKE,OAAL,CAAaL,OAAOM,OAAOC,WAAP,CAAmBP,GAAnB,EAAwB,IAAxB,EAA8BH,IAA9B,CAAmCW,aAAa;AAClEA,0BAAUC,QAAV,CAAmB,SAAnB,EAA8BZ,IAA9B,CAAmC,MAAMa,YAAN,IAAsB;AACvD,sBAAIC,gBAAgBD,aAAaE,gBAAb,EAApB;AACA,sBAAIC,KAAK,MAAMH,aAAaI,WAAb,EAAf;AACAH,gCAAcI,eAAd,CAA8BF,EAA9B,EAAkChB,IAAlC,CAAuCmB,MAAM;AAC3CA,uBAAGhH,WAAH,CAAe,CAACgH,GAAGhF,aAAH,CAAiBgF,GAAG3L,WAApB,EAAiCmK,SAAjC,CAAD,CAAf;AACD,mBAFD;AAGD,iBAND;AAOD,eARmB,CAApB;AASD;AACF;AACD;;;;AAID;;AAED,cAAMyB,MAAN,GAAe;AACb,gBAAMjC,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA,cAAI2F,aAAa,KAAKT,0BAAL,CAAgC+E,YAAhC,CAAjB;AACA,cAAI,CAACtE,UAAL,EAAiB;AACjB,gBAAMO,cAAc,KAAKC,aAAL,CAAmBR,UAAnB,CAApB;;AAEA,cAAGO,WAAH,EAAgB;AACd,iBAAKjB,WAAL,CAAiBiB,WAAjB;AACA;AACD;;AAED,gBAAMiG,eAAe,MAAM,KAAKC,8BAAL,CAAoCzG,UAApC,CAA3B;;AAGA,cAAI0G,OAAO,MAAMd,OAAOe,qBAAP,CAA6B,iCAA7B,CAAjB;AACAD,eAAKE,KAAL;AACAF,eAAKG,kBAAL,CAAwB,MAAxB,EAAgC,gBAAhC;AACAH,eAAKI,QAAL,CAAc,YAAY9G,WAAWnD,IAAX,CAAgB+C,IAA1C;AACA,gBAAMmH,aAAa,MAAML,KAAKM,WAAL,CAAiBR,YAAjB,CAAzB;;AAEA,gBAAMS,UAAUP,KAAKQ,kBAAL,GAA0BC,SAA1B,EAAhB;AACA,cAAGF,YAAY,EAAf,EAAmB;;AAEnB,eAAI,MAAMG,SAAV,IAAuBL,UAAvB,EAAmC;AACjC,kBAAM/L,OAAO,MAAMqM,MAAMD,UAAU9B,GAAhB,EAAqBH,IAArB,CAA0BmC,KAAKA,EAAEC,IAAF,EAA/B,CAAnB;;AAEA,kBAAMC,YAAYxM,KAAKyM,KAAL,CAAW,IAAX,CAAlB;;AAEAC,mBAAOC,SAAP,CAAiBC,cAAjB,GAAkC,UAAShD,KAAT,EAAgB7H,GAAhB,EAAqB8K,IAArB,EAA2B;AAC3D,qBAAO,KAAKC,SAAL,CAAe,CAAf,EAAkBlD,KAAlB,IAA2BiD,IAA3B,GAAkC,KAAKC,SAAL,CAAe/K,GAAf,CAAzC;AACD,aAFD;AAGAyK,sBAAUJ,UAAUW,IAApB,IAA4BP,UAAUJ,UAAUW,IAApB,EAA0BH,cAA1B,CAAyCR,UAAUY,EAAnD,EAAuDZ,UAAUY,EAAV,GAAehI,WAAWnD,IAAX,CAAgB+C,IAAhB,CAAqBxF,MAA3F,EAAmG6M,OAAnG,CAA5B;;AAEA,kBAAMgB,UAAUT,UAAUU,IAAV,CAAe,IAAf,CAAhB;AACA,kBAAMtC,OAAOuC,KAAP,CAAaC,QAAb,CAAsBhB,UAAU9B,GAAhC,EAAqC2C,OAArC,CAAN;AACA,kBAAMrC,OAAOyC,YAAP,CAAoBjB,UAAU9B,GAA9B,CAAN;AACA,kBAAMgD,OAAOC,MAAP,CAAcnB,UAAU9B,GAAxB,CAAN;AACD;AACF;;AAEDkD,yBAAiB;AACf,gBAAMlE,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA,gBAAMkK,WAAW,KAAKjE,iBAAL,CAAuBgE,YAAvB,CAAjB;AACA,cAAIC,QAAJ,EAAc;AACZ,iBAAKjF,WAAL,CAAiBiF,QAAjB;AACD;AACF;;AAED,cAAMkE,gBAAN,GAAyB;AACvB,gBAAMnE,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA;AACA,cAAI2F,aAAa,KAAKT,0BAAL,CAAgC+E,YAAhC,CAAjB;;AAEA;AACA,gBAAMkC,eAAe,MAAM,KAAKC,8BAAL,CAAoCzG,UAApC,CAA3B;;AAEA,eAAK0I,kBAAL,CAAwBlC,YAAxB,EAAsCxG,WAAWnD,IAAX,CAAgB+C,IAAtD;AACD;;AAED,cAAM6G,8BAAN,CAAqCzG,UAArC,EAAiD;AAC/C,cAAIkC,QAAQ,MAAM1I,UAAUmP,OAAV,EAAlB;AACA,cAAIC,MAAM,MAAM1G,MAAM2G,EAAN,CAASV,KAAT,CAAenG,MAAf,CAAsB8G,QAAQ;AAC5C,gBAAI,CAACA,KAAK/G,kBAAV,EAA8B,OAAO,KAAP;AAC9B,mBAAO+G,KAAK/G,kBAAL,CAAwBgH,IAAxB,CAA6B7F,MAAMA,GAAGtD,IAAH,IAAWI,WAAWJ,IAAzD,CAAP;AACD,WAHe,EAGboJ,OAHa,EAAhB;AAIA,gBAAMxC,eAAe,EAArB;;AAEA,eAAK,MAAMtD,EAAX,IAAiB0F,GAAjB,EAAsB;AACpB,kBAAM5N,OAAO,MAAMqM,MAAMnE,GAAGoC,GAAT,EAAcH,IAAd,CAAmBmC,KAAKA,EAAEC,IAAF,EAAxB,CAAnB;AACA,kBAAM0B,UAAU,KAAKnO,cAAL,CAAoBE,IAApB,CAAhB;AACA,iBAAK,MAAMoM,SAAX,IAAwB,KAAK5F,iBAAL,CAAuBxB,UAAvB,EAAmC,IAAnC,EAAyCiJ,OAAzC,CAAxB,EAA2E;AACzE,oBAAMlB,OAAOX,UAAUvK,IAAV,CAAe1D,GAAf,CAAmByL,KAAnB,CAAyBmD,IAAzB,GAAgC,CAA7C;AACA,oBAAMC,KAAKZ,UAAUvK,IAAV,CAAe1D,GAAf,CAAmByL,KAAnB,CAAyBsE,MAApC;AACA1C,2BAAa5I,IAAb,CAAkB,EAAEsF,IAAIA,GAAGoC,GAAH,CAAOwC,SAAP,CAAiB5E,GAAGoC,GAAH,CAAO6D,WAAP,CAAmB,GAAnB,IAA0B,CAA3C,IAAgD,IAAhD,GAAuDpB,IAA7D,EAAmEzC,KAAKpC,GAAGoC,GAA3E,EAAgFyC,IAAhF,EAAsFC,EAAtF,EAAlB;AACD;AACF;;AAED,iBAAOxB,YAAP;AACD;;AAED,cAAMkC,kBAAN,CAAyBE,GAAzB,EAA8BQ,cAA9B,EAA8C;AAC5C,cAAI1C,OAAO,MAAMd,OAAOe,qBAAP,CAA6B,iCAA7B,CAAjB;AACAD,eAAKE,KAAL;AACAF,eAAKI,QAAL,CAAc,mBAAmBsC,cAAjC;AACA,iBAAO1C,KAAKM,WAAL,CAAiB4B,GAAjB,CAAP;AACD;;AAED,cAAMS,WAAN,GAAoB;AAClB,cAAIC,SAAJ,EAAeC,OAAf,EAAwBzE,SAAxB;AACA,gBAAMR,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;AACA,gBAAM2F,aAAa,KAAKT,0BAAL,CAAgC+E,YAAhC,CAAnB;AACA,cAAItE,UAAJ,EAAgB;AACd8E,wBAAY9E,WAAWnD,IAAX,CAAgB+C,IAA5B;AACA0J,wBAAY,MAAM,KAAK9D,qBAAL,CAA2BV,SAA3B,CAAlB;AACAyE,sBAAU,MAAM,KAAKrE,uBAAL,CAA6BJ,SAA7B,CAAhB;AACD;AACD,iBAAO,EAAEA,SAAF,EAAawE,SAAb,EAAwBC,OAAxB,EAAP;AACD;AACD;;AAEA;;AAEA;AACAC,qBAAarO,IAAb,EAAmB;AACjB,cAAIsO,eAAe,KAAKC,IAAL,CAAU,gBAAV,EAA4BvO,IAA5B,EAAkC,UAAlC,CAAnB;;AAEA,iBAAOsO,iBAAiB,IAAxB,EAA8B;AAC5B,gBAAIA,aAAa5M,IAAb,IAAqB4M,aAAa5M,IAAb,CAAkB8M,MAAlB,CAAyB/J,IAAzB,KAAkC,UAA3D,EAAuE;AACrE;AACD;AACD6J,2BAAe,KAAKC,IAAL,CAAU,gBAAV,EAA4BD,aAAa7K,UAAzC,EAAqD,UAArD,CAAf;AACD;AACD,iBAAO6K,YAAP;AACD;;AAEDC,aAAKtF,IAAL,EAAWjJ,IAAX,EAAiB;AACf,iBAAOA,SAAS,IAAhB,EAAsB;AACpB,gBAAI,KAAKyO,YAAL,CAAkBxF,IAAlB,EAAwBjJ,IAAxB,CAAJ,EAAmC;AACjC,qBAAOA,IAAP;AACD;AACDA,mBAAOA,KAAKyD,UAAZ;AACD;AACD,iBAAO,IAAP;AACD;;AAEDgL,qBAAaxF,IAAb,EAAmBjJ,IAAnB,EAAyB;AACvB,cAAIiJ,gBAAgByF,KAApB,EAA2B;AACzB,mBAAOzF,KAAK9J,GAAL,CAASwP,QAAQ,KAAKF,YAAL,CAAkBE,IAAlB,EAAwB3O,IAAxB,CAAjB,EAAgD4O,MAAhD,CAAuD,CAACC,IAAD,EAAOF,IAAP,KAAgBE,QAAQF,IAA/E,EAAqF,KAArF,CAAP;AACD;AACD,iBAAO3O,KAAK0B,IAAL,IAAa1B,KAAK0B,IAAL,CAAUuH,IAAV,KAAmBA,IAAvC;AACD;;AAEF;;AAGC6F,oBAAYC,eAAZ,EAA6BC,KAA7B,EAAoC;AAClC,cAAIC,WAAW,EAAE5P,QAAQ0P,eAAV,EAA2BxP,MAAMwP,eAAjC,EAAf;AACA,gBAAMG,aAAa,KAAKA,UAAxB;AACA,eAAKtP,UAAL,GAAkB,KAAKA,UAAL,CAAgBuP,cAAhB,CAA+B,OAAO;AACtDC,qBAAS;AACPrP,uBAASP,eAAe;AACtB,sBAAMQ,OAAO,KAAK8B,mCAAL,CAAyCtC,WAAzC,EAAsDvB,MAAMgR,QAAN,CAAtD,CAAb,CADsB,CAC+D;AACrF,oBAAIzQ,EAAE6Q,eAAF,CAAkBrP,KAAK0B,IAAvB,CAAJ,EAAkC;AAChC1B,uBAAK0B,IAAL,CAAUoF,KAAV,GAAkBkI,KAAlB;AACD;AACF;AANM;AAD6C,WAAP,CAA/B,EASdnP,IATJ;AAUA,eAAKyP,QAAL,CAAcJ,UAAd;AACD;AACD;;AAEA;;AAEA,cAAMK,qBAAN,CAA4B9B,GAA5B,EAAiC+B,qBAAjC,EAAwD;AACtD,cAAIjE,OAAO,MAAMd,OAAOe,qBAAP,CAA6B,iCAA7B,CAAjB;AACAD,eAAKE,KAAL;AACAF,eAAKI,QAAL,CAAc,oBAAd;AACA,iBAAOJ,KAAKM,WAAL,CAAiB4B,GAAjB,EAAsB+B,qBAAtB,CAAP;AACD;;AAEDC,+BAAuB;AACrB,cAAIC,qBAAJ;AACA,eAAKlQ,WAAL,CAAiBsB,QAAjB,CAA0B;AACxB6O,qCAAyB3P,IAAzB,EAA+B;AAC7B,kBAAIA,QAAQA,KAAK0B,IAAL,CAAUkI,WAAlB,IAAiC5J,KAAK0B,IAAL,CAAUkI,WAAV,CAAsBX,IAAtB,IAA8B,kBAAnE,EAAuF;AACrFyG,wCAAwB1P,KAAK0B,IAAL,CAAUkI,WAAV,CAAsBgG,IAAtB,CAA2BA,IAA3B,CAAgCzQ,GAAhC,CAAoCwP,QAAQA,KAAK9G,GAAL,CAASpD,IAArD,CAAxB;AACAzE,qBAAKgB,IAAL;AACD;AACF;AANuB,WAA1B;AAQA,iBAAO0O,yBAAyB,EAAhC;AACD;;AAED,cAAMG,qBAAN,GAA8B;AAC5B,gBAAMpC,MAAM,MAAM,KAAKqC,gBAAL,EAAlB;AACA,cAAIrC,IAAIxO,MAAJ,IAAc,CAAlB,EAAqB;AACnB;AACD;;AAED,cAAI8Q,kBAAkB,KAAKN,oBAAL,EAAtB;AACA,cAAID,wBAAwB/B,IAAItO,GAAJ,CAAQwP,QAAQoB,gBAAgBnK,QAAhB,CAAyB,KAAKoK,8BAAL,CAAoCrB,KAAK5G,EAAzC,CAAzB,CAAhB,CAA5B;AACA,gBAAMkI,gBAAgB,MAAM,KAAKV,qBAAL,CAA2B9B,GAA3B,EAAgC+B,qBAAhC,CAA5B;;AAEA,cAAIS,cAAchR,MAAd,KAAyB,CAA7B,EAAgC;AAC9B;AACD;AACDwL,iBAAOyF,IAAP,CAAa,GAAED,cAAchR,MAAO,sBAApC;;AAEAgR,wBAAczF,OAAd,CAAsB2F,QAAQ;AAC5B,iBAAKC,oBAAL,CAA0BD,KAAKpI,EAA/B,EAAmCtD,QAAQ,KAAK4L,iBAAL,CAAuB5L,IAAvB,CAA3C;AACA,kBAAM0E,eAAe,KAAKrH,mCAAL,CAAyC,KAAKtC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;AACA,gBAAI0N,OAAOzD,aAAa/I,MAAb,CAAoBpC,GAApB,CAAwB4D,GAAxB,CAA4BgL,IAA5B,GAAmC,CAA9C;AACA,iBAAK/N,YAAL,CAAkBS,MAAlB,GAA2BtB,IAAI,EAAC4O,IAAD,EAAOC,IAAI,CAAX,EAAJ,CAA3B;AACD,WALD;AAMD;;AAED,cAAMiD,gBAAN,GAAyB;AACvB,gBAAMQ,UAAU,KAAKzR,YAAL,CAAkByR,OAAlC;AACA,cAAIC,OAAO,MAAMD,QAAQE,SAAR,EAAjB;;AAEA,cAAID,SAAS,mBAAb,EAAkC;AAChC9F,mBAAOyF,IAAP,CAAY,6CAAZ;AACA,mBAAO,EAAP;AACD;;AAED,cAAIO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAJ;AACAA,cAAIC,SAAJ,GAAgBH,IAAhB;AACA,cAAI9C,MAAMgD,IAAIE,UAAJ,CAAe,CAAf,EAAkBC,OAAlB,CAA0BC,gBAA1B,CAA2C,MAA3C,EAAmD1R,GAAnD,CAAuD2R,MAAMA,GAAG/I,EAAhE,CAAV;;AAEA,gBAAMgJ,YAAYR,KAAKjE,KAAL,CAAW,IAAX,CAAlB;;AAEA,gBAAM0E,kBAAkB,EAAxB;AACA,eAAK,MAAMjJ,EAAX,IAAiB0F,GAAjB,EAAsB;AACpB,iBAAK,MAAMb,IAAX,IAAmBmE,SAAnB,EAA8B;AAC5B,oBAAME,YAAYrE,KAAK3F,OAAL,CAAa,UAAUc,EAAV,GAAe,IAA5B,CAAlB;AACA,kBAAIkJ,cAAc,CAAC,CAAnB,EAAsB;AACpBD,gCAAgBvO,IAAhB,CAAqB,EAAEsF,EAAF,EAAMoC,KAAKmG,OAAX,EAAoB1D,MAAMmE,UAAU9J,OAAV,CAAkB2F,IAAlB,CAA1B,EAAmDC,IAAIoE,YAAY,CAAnE,EAArB;AACA;AACD;AACF;AACF;AACD,iBAAOD,eAAP;AACD;;AAEDE,2BAAmB;AACjB,eAAKd,oBAAL,CAA0B,qBAA1B,EAAiDrI,MAAM,KAAKoJ,eAAL,CAAqBpJ,GAAGlD,UAAxB,CAAvD;AACD;;AAEDuM,yBAAiB;AACf,eAAKhB,oBAAL,CAA0B,gBAA1B,EAA4CrI,MAAM,KAAKsJ,aAAL,CAAmBtJ,GAAGlD,UAAtB,CAAlD;AACD;;AAEDyM,yBAAiB;AACf,eAAKlB,oBAAL,CAA0B,gBAA1B,EAA4CrI,MAAM,KAAKwJ,aAAL,CAAmBxJ,GAAGlD,UAAtB,CAAlD;AACD;;AAED2M,wBAAgB;AACd,eAAKpB,oBAAL,CAA0B,cAA1B,EAA0CrI,MAAM,KAAK0J,YAAL,CAAkB1J,GAAGlD,UAArB,CAAhD;AACD;;AAED,cAAMuL,oBAAN,CAA2BvL,UAA3B,EAAuC6M,oBAAvC,EAA6D;AAC3D,gBAAMxC,aAAa,KAAKA,UAAxB;AACA,gBAAMnN,YAAY,KAAK7C,cAAvB;;AAEA,cAAIyS,mBAAmB,EAAE9M,UAAF,EAAvB;;AAEA,cAAI+M,aAAJ;AACA,eAAKhS,UAAL,GAAkB,KAAKA,UAAL,CAAgBuP,cAAhB,CAA+B,OAAO;AACtDC,qBAAS;AACPrP,uBAASP,eAAe;AACtB,oBAAIqS,aAAa,KAAKxQ,mBAAL,CAAyB7B,WAAzB,EAAsCuC,UAAU0H,KAAhD,CAAjB;AACA,oBAAIqI,aAAa,KAAKhQ,mCAAL,CAAyCtC,WAAzC,EAAsD,KAAKN,cAA3D,CAAjB;AACA;AACA0S,gCAAgBF,qBAAqBC,gBAArB,CAAhB;AACA,oBAAIE,eAAe3R,SAAnB,EAA8B;AAC5B4R,6BAAWC,gBAAX,CAA4B,MAA5B,EAAoCH,aAApC;AACD,iBAFD,MAEO,IAAI,KAAKnD,YAAL,CAAkBqD,WAAW7I,IAA7B,EAAmC4I,WAAWpO,UAA9C,CAAJ,EAA+D;AACpEoO,6BAAWG,WAAX,CAAuBJ,aAAvB;AACD,iBAFM,MAEA;AACLE,6BAAWC,gBAAX,CAA4B,MAA5B,EAAoCH,aAApC;AACD;AACF;AAbM;AAD6C,WAAP,CAA/B,EAgBd/R,IAhBJ;;AAkBA,cAAIoS,YAAJ;AACA,eAAKzS,WAAL,CAAiBsB,QAAjB,CAA0B;AACxBuH,0BAAcrI,IAAd,EAAoB;AAClB,kBAAI,CAACiS,YAAD,IAAiBjS,KAAK0B,IAAL,CAAUoF,KAAV,IAAmB6K,iBAAiB9M,UAAzD,EAAqE;AACnEoN,+BAAejS,IAAf;AACD;AACF,aALuB;AAMxBuE,uBAAWvE,IAAX,EAAiB;AACf,kBAAIA,KAAK0B,IAAL,CAAU+C,IAAV,IAAkBkN,iBAAiB9M,UAAvC,EAAmD;AACjDoN,+BAAejS,IAAf;AACAA,qBAAKgB,IAAL;AACD;AACF;AAXuB,WAA1B;AAaA,eAAKmD,WAAL,CAAiB,CAAC8N,YAAD,CAAjB,EAAiC,IAAjC;;AAEA,eAAK3C,QAAL,CAAcJ,UAAd;AACD;;AAEDiC,wBAAgBe,WAAhB,EAA6B;AAC3B,iBAAOxT,SAAS,sBAAsB,wBAAtB,GAAiD,IAA1D,EAAgE;AACrEyT,iBAAK3T,EAAE4T,aAAF,CAAgBF,WAAhB;AADgE,WAAhE,CAAP;AAGD;;AAED;AACAb,sBAAcgB,YAAd,EAA4B;AAC1B,iBAAO7T,EAAE+H,WAAF,CAAc,KAAd,EAAqB/H,EAAEqG,UAAF,CAAawN,YAAb,CAArB,EAAiD,EAAjD,EAAqD7T,EAAE8T,cAAF,CAAiB,CAAC9T,EAAE+T,eAAF,CAAkB/T,EAAEgU,gBAAF,CAAmBhU,EAAEiU,cAAF,EAAnB,EAAuCjU,EAAEqG,UAAF,CAAa,sBAAb,CAAvC,CAAlB,CAAD,CAAjB,CAArD,CAAP;AACD;;AAED0M,sBAAcc,YAAd,EAA4B;AAC1B,iBAAO7T,EAAE+H,WAAF,CAAc,KAAd,EAAqB/H,EAAEqG,UAAF,CAAawN,YAAb,CAArB,EAAiD,CAAC7T,EAAE+F,UAAF,CAAa,UAAb,CAAD,CAAjD,EAA6E/F,EAAE8T,cAAF,CAAiB,CAAC9T,EAAEkU,mBAAF,CAAsBlU,EAAEmU,oBAAF,CAAuB,GAAvB,EAA4BnU,EAAEgU,gBAAF,CAAmBhU,EAAEiU,cAAF,EAAnB,EAAuCjU,EAAEqG,UAAF,CAAa,sBAAb,CAAvC,CAA5B,EAA0GrG,EAAEqG,UAAF,CAAa,UAAb,CAA1G,CAAtB,CAAD,CAAjB,CAA7E,CAAP;AACD;;AAED4M,qBAAamB,SAAb,EAAwB;AACtB,iBAAOpU,EAAEqU,gBAAF,CAAmBrU,EAAEqG,UAAF,CAAa+N,SAAb,CAAnB,EAA4C,IAA5C,EAAkDpU,EAAEsU,SAAF,CAAY,CAACtU,EAAE+H,WAAF,CAAc,aAAd,EAA6B/H,EAAE+F,UAAF,CAAa,aAAb,CAA7B,EAA0D,EAA1D,EAA8D/F,EAAE8T,cAAF,CAAiB,EAAjB,CAA9D,CAAD,CAAZ,CAAlD,EAAsJ,EAAtJ,CAAP;AACD;;AAEDjC,0BAAkB0C,QAAlB,EAA4B;AAC1B,cAAIV,eAAeU,SAASlO,UAA5B;AACA,cAAImO,aAAa,KAAKhD,8BAAL,CAAoCqC,YAApC,CAAjB;AACAU,mBAASlO,UAAT,GAAsBmO,UAAtB;AACA,iBAAOxU,EAAE+H,WAAF,CAAc,KAAd,EAAqB/H,EAAEqG,UAAF,CAAamO,UAAb,CAArB,EAA+C,EAA/C,EAAmDxU,EAAE8T,cAAF,CAAiB,CAAC9T,EAAE+T,eAAF,CAAkB/T,EAAEyU,cAAF,CAAiBzU,EAAEgU,gBAAF,CAAmBhU,EAAEiU,cAAF,EAAnB,EAAuCjU,EAAEqG,UAAF,CAAa,KAAb,CAAvC,CAAjB,EAA8E,CAACrG,EAAE4T,aAAF,CAAgB,MAAMC,YAAtB,CAAD,CAA9E,CAAlB,CAAD,CAAjB,CAAnD,CAAP;AACD;;AAEDrC,uCAA+BvL,IAA/B,EAAqC;AACnC,iBAAOA,KAAKuH,SAAL,EAAP;AACD;;AAED,cAAMkH,YAAN,CAAmBC,WAAnB,EAAgCC,YAAhC,EAA8C;AAC5C,cAAIC,QAAQ,MAAM5I,OAAO6I,MAAP,CAAcH,WAAd,EAA2BC,YAA3B,CAAlB;AACA,iBAAO,IAAIG,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AACtC,gBAAIJ,KAAJ,EAAW;AACTG,sBAAQH,KAAR;AACD,aAFD,MAEO;AACLI,qBAAO,iBAAP;AACD;AACF,WANM,CAAP;AAOD;;AAED;;AAEAC,kBAAUvJ,GAAV,EAAewJ,UAAf,EAA2BC,UAA3B,EAAuC;AACrC,gBAAM7R,YAAY,KAAK7C,cAAvB;AACA,gBAAMgQ,aAAa,KAAKA,UAAxB;AACA,eAAKtP,UAAL,GAAkB,KAAKA,UAAL,CAAgBuP,cAAhB,CAA+B,OAAO;AACtDC,qBAAS;AACPrP,uBAASP,eAAe;AACtB,oBAAIqU,0BAA0B,KAAKnT,QAAL,CAAclB,WAAd,EAA2BQ,QAAQ;AAC/D,yBAAOxB,EAAEsV,mBAAF,CAAsB9T,IAAtB,KAA+BA,KAAK0B,IAAL,CAAUqS,MAAV,CAAiBjN,KAAjB,IAA0BqD,GAAhE;AACD,iBAF6B,CAA9B;AAGA,oBAAIhB,eAAe,KAAKrH,mCAAL,CAAyCtC,WAAzC,EAAsDuC,SAAtD,CAAnB;AACA,oBAAI,CAAC8R,uBAAL,EAA8B;AAC5B,sBAAIG,kBAAkBxV,EAAEyV,iBAAF,CAAoB,CAACzV,EAAE0V,eAAF,CAAkB1V,EAAEqG,UAAF,CAAa8O,UAAb,CAAlB,EAA4CnV,EAAEqG,UAAF,CAAa8O,UAAb,CAA5C,CAAD,CAApB,EAA6FnV,EAAE4T,aAAF,CAAgBjI,GAAhB,CAA7F,CAAtB;AACA3K,8BAAYkC,IAAZ,CAAiBkO,IAAjB,CAAsBuE,OAAtB,CAA8BH,eAA9B;AACD,iBAHD,MAGO,IAAI,CAACH,wBAAwBnS,IAAxB,CAA6B0S,UAA7B,CAAwCxG,IAAxC,CAA6CyG,QAAQA,KAAKC,QAAL,CAAc7P,IAAd,IAAsBkP,UAA3E,CAAL,EAA6F;AAClGE,0CAAwBnS,IAAxB,CAA6B0S,UAA7B,CAAwC3R,IAAxC,CAA6CjE,EAAEqG,UAAF,CAAa8O,UAAb,CAA7C;AACD;AACD,oBAAI,CAACC,UAAL,EAAiB;AACfzK,+BAAaoL,WAAb,CAAyB/V,EAAEgU,gBAAF,CAAmBhU,EAAEqG,UAAF,CAAa8O,UAAb,CAAnB,EAA6CnV,EAAEqG,UAAF,CAAasE,aAAazH,IAAb,CAAkB+C,IAA/B,CAA7C,CAAzB;AACD;AACF;AAfM;AAD6C,WAAP,CAA/B,EAkBd5E,IAlBJ;AAmBA,eAAKyP,QAAL,CAAcJ,UAAd;AACD;;AAED;;AAEA;AACAsF,uBAAe7P,WAAf,EAA4B8P,iBAA5B,EAA+CC,gBAA/C,EAAiE;AAC/D,iBAAO/P,YAAYkC,MAAZ,CAAmBhC,cAAc;AACtC,mBAAO,KAAK8P,kBAAL,CAAwB9P,UAAxB,EAAoC4P,iBAApC,CAAP;AACD,WAFM,EAEJ5N,MAFI,CAEGhC,cAAc;AACtB,kBAAM+P,cAAc/P,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,EAAkDzE,IAAtE;AACA,mBAAO,CAAC,KAAK6U,UAAL,CAAgBD,WAAhB,EAA6BF,gBAA7B,CAAR;AACD,WALM,EAKJvV,GALI,CAKA0F,cAAc;AACnB,mBAAO,KAAKI,mCAAL,CAAyCJ,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAzC,EAA4F/C,IAAnG;AACD,WAPM,CAAP;AAQD;;AAEDoT,sBAAclE,OAAd,EAAuB;AACrB,cAAImE,WAAW,KAAf;AACAnE,kBAAQpG,OAAR,CAAgBnG,aAAa;AAC3B,gBAAI7F,EAAEwW,iBAAF,CAAoB3Q,UAAU3C,IAA9B,CAAJ,EAAyC;AACvCqT,yBAAW,IAAX;AACD,aAFD,MAEO;AACL1Q,wBAAUvD,QAAV,CAAmB;AACjBmU,gCAAgBjV,IAAhB,EAAsB;AACpB+U,6BAAW,IAAX;AACA/U,uBAAKgB,IAAL;AACD;AAJgB,eAAnB;AAMD;AACF,WAXD;;AAaA,iBAAO+T,QAAP;AACD;;AAEDG,sBAActE,OAAd,EAAuB;AACrB,cAAIuE,UAAU,KAAd;AACAvE,kBAAQpG,OAAR,CAAgBnG,aAAa;AAC3BA,sBAAUvD,QAAV,CAAmB;AACjBsU,6BAAepV,IAAf,EAAqB;AACnBmV,0BAAU,IAAV;AACAnV,qBAAKgB,IAAL;AACD;AAJgB,aAAnB;AAMD,WAPD;;AASA,iBAAO,CAACmU,OAAR;AACD;;AAEDR,2BAAmB9P,UAAnB,EAA+B4P,iBAA/B,EAAkD;AAChD,iBAAO5P,WAAWC,KAAX,CAAiBC,UAAjB,CAA4BF,WAAWnD,IAAX,CAAgB+C,IAA5C,KAAqD,CAACgQ,kBAAkBhR,UAAlB,CAA6BqB,KAA7B,CAAmCC,UAAnC,CAA8CF,WAAWnD,IAAX,CAAgB+C,IAA9D,CAA7D;AACD;;AAED4Q,yBAAiB1Q,WAAjB,EAA8B8P,iBAA9B,EAAiDC,gBAAjD,EAAmE;AACjE,gBAAMtL,WAAW,CAAC,GAAG,IAAI5D,GAAJ,CAAQb,YAAYkC,MAAZ,CAAmBhC,cAAc;AAC5D,mBAAOA,WAAWC,KAAX,CAAiBC,UAAjB,CAA4BF,WAAWnD,IAAX,CAAgB+C,IAA5C,KAAqD,CAACgQ,kBAAkBhR,UAAlB,CAA6BqB,KAA7B,CAAmCC,UAAnC,CAA8CF,WAAWnD,IAAX,CAAgB+C,IAA9D,CAA7D;AACD,WAF4B,EAE1BtF,GAF0B,CAEtB0F,cAAc;AACnB,mBAAOA,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAP;AACD,WAJ4B,CAAR,CAAJ,CAAjB;;AAMA,iBAAO2E,SAASvC,MAAT,CAAgB3B,WAAW;AAChC,kBAAMoQ,yBAAyB,KAAKT,UAAL,CAAgB3P,QAAQlF,IAAxB,EAA8B0U,gBAA9B,CAA/B;AACA,kBAAMa,+BAA+BrQ,QAAQQ,kBAAR,CAA2BkI,IAA3B,CAAgC4H,qBAAqB,KAAKX,UAAL,CAAgBW,iBAAhB,EAAmCd,gBAAnC,CAArD,CAArC;AACA,kBAAMe,4BAA4BvQ,QAAQO,cAAR,CAAuBmI,IAAvB,CAA4B3B,aAAa,CAAC,KAAK4I,UAAL,CAAgB5I,SAAhB,EAA2ByI,gBAA3B,CAA1C,CAAlC;;AAEA,mBAAO,KAAKgB,iBAAL,CAAuBJ,sBAAvB,EAA+CC,4BAA/C,EAA6EE,yBAA7E,CAAP;AACD,WANM,EAMJtW,GANI,CAMA+F,WAAW;AAChB,kBAAMyQ,oCAAoCzQ,QAAQQ,kBAAR,CAA2BkI,IAA3B,CAAgC4H,qBAAqB,CAAC,KAAKX,UAAL,CAAgBW,iBAAhB,EAAmCd,gBAAnC,CAAtD,CAA1C;AACA,mBAAO,EAAEhT,MAAM,KAAKuD,mCAAL,CAAyCC,OAAzC,EAAkDxD,IAA1D,EAAgEkU,yBAAyB,KAAKf,UAAL,CAAgB3P,QAAQlF,IAAxB,EAA8B0U,gBAA9B,CAAzF,EAA0IiB,iCAA1I,EAAP;AACD,WATM,CAAP;AAUD;;AAEDD,0BAAkBJ,sBAAlB,EAA0CC,4BAA1C,EAAwEE,yBAAxE,EAAmG;AACjG,iBAAO,CAACH,sBAAD,IAA2BC,4BAA3B,IAA2D,CAACA,gCAAgCD,sBAAjC,KAA4DG,yBAA9H;AACD;;AAEDI,qBAAajF,OAAb,EAAsBkF,SAAtB,EAAiCC,YAAjC,EAA+CjR,KAA/C,EAAsDkR,oBAAtD,EAA4ElB,aAA5E,EAA2FmB,cAA3F,EAA2G;AACzG,cAAID,wBAAwBD,aAAa9W,MAAb,GAAsB,CAAlD,EAAqD;AACnDwL,mBAAOyF,IAAP,CAAY,mGAAZ;AACD;AACD,cAAIqC,eAAJ;AACAwD,uBAAavL,OAAb,CAAqB0L,eAAeA,YAAYC,gBAAZ,GAA+BD,YAAYN,uBAAZ,GAAsCM,YAAYxU,IAAlD,GAAyDlD,EAAEqG,UAAF,CAAaqR,YAAYxU,IAAZ,CAAiB+C,IAAjB,GAAwB,SAArC,CAA5H;AACA,cAAIsR,aAAa9W,MAAb,IAAuB,CAA3B,EAA8B;AAC5BsT,8BAAkB/T,EAAE+T,eAAF,CAAkBwD,aAAa,CAAb,EAAgBrU,IAAlC,CAAlB;AACD,WAFD,MAEO,IAAIqU,aAAa9W,MAAb,GAAsB,CAA1B,EAA6B;AAClCsT,8BAAkB/T,EAAE+T,eAAF,CAAkB/T,EAAE4X,gBAAF,CAAmBL,aAAa5W,GAAb,CAAiBmI,KAAK9I,EAAE6X,cAAF,CAAiB/O,EAAE6O,gBAAnB,EAAqC7O,EAAE5F,IAAvC,EAA6C,KAA7C,EAAoD,IAApD,CAAtB,CAAnB,CAAlB,CAAlB;AACD;;AAED,cAAI4U,gBAAgB1F,QAAQzR,GAAR,CAAYoX,KAAK;AACnC;AACAA,cAAE7U,IAAF,CAAO1D,GAAP,GAAa,IAAb;AACAuY,cAAE7U,IAAF,CAAO+H,KAAP,GAAe,IAAf;AACA8M,cAAE7U,IAAF,CAAOE,GAAP,GAAa,IAAb;AACA,mBAAO2U,EAAE7U,IAAT;AACD,WANmB,CAApB;AAOA,cAAI6Q,eAAJ,EAAqB;AACnB+D,0BAAc7T,IAAd,CAAmB8P,eAAnB;AACD,WAFD,MAEO,IAAIyD,oBAAJ,EAA0B;AAC/BM,4BAAgB,CAAC9X,EAAE+T,eAAF,CAAkB3B,QAAQ,CAAR,EAAWlP,IAA7B,CAAD,CAAhB;AACD;AACD,gBAAM8U,YAAYhY,EAAE+H,WAAF,CAAc,QAAd,EAAwB/H,EAAEqG,UAAF,CAAa,uCAAb,CAAxB,EAA+EiR,SAA/E,EAA0FtX,EAAE8T,cAAF,CAAiBgE,aAAjB,CAA1F,CAAlB;AACAE,oBAAUC,KAAV,GAAkB3B,aAAlB;AACA0B,oBAAUE,MAAV,GAAmBT,cAAnB;AACAnR,gBAAMkN,WAAN,CAAkBwE,SAAlB;AACA,eAAK,IAAIlP,IAAI,CAAb,EAAgBA,IAAIsJ,QAAQ3R,MAAR,GAAiB,CAArC,EAAwCqI,GAAxC,EAA6C;AAC3CsJ,oBAAQtJ,CAAR,EAAWqP,MAAX;AACD;AACD,cAAIC,UAAJ;AACA,cAAI3D,iBAAiBzU,EAAEyU,cAAF,CAAiBzU,EAAEqG,UAAF,CAAa,4CAAb,CAAjB,EAA6EiR,SAA7E,CAArB;AACA,cAAIhB,aAAJ,EAAmB;AACjBrK,mBAAOyF,IAAP,CAAY,8DAAZ;AACA+C,6BAAiBzU,EAAEqY,eAAF,CAAkB5D,cAAlB,CAAjB;AACD;AACD,cAAI8C,aAAa9W,MAAb,IAAuB,CAA3B,EAA8B;AAC5B,gBAAI8W,aAAa,CAAb,EAAgBH,uBAApB,EAA6C;AAC3C,oBAAMkB,eAAef,aAAa,CAAb,EAAgBJ,iCAAhB,GAAoD,KAApD,GAA4D,OAAjF;AACAiB,2BAAa,CAACpY,EAAEuY,mBAAF,CAAsBD,YAAtB,EAAoC,CAACtY,EAAEwY,kBAAF,CAAqBjB,aAAa,CAAb,EAAgBrU,IAArC,EAA2CuR,cAA3C,CAAD,CAApC,CAAD,CAAb;AACD,aAHD,MAGO;AACL2D,2BAAa,CAACpY,EAAEkU,mBAAF,CAAsBlU,EAAEmU,oBAAF,CAAuB,GAAvB,EAA4BoD,aAAa,CAAb,EAAgBrU,IAA5C,EAAkDuR,cAAlD,CAAtB,CAAD,CAAb;AACD;AACF,WAPD,MAOO,IAAI8C,aAAa9W,MAAb,GAAsB,CAA1B,EAA6B;AAClC,kBAAMgY,gBAAgBzY,EAAEyY,aAAF,CAAgBlB,aAAa5W,GAAb,CAAiBmI,KAAK9I,EAAE6X,cAAF,CAAiB/O,EAAE6O,gBAAnB,EAAqC7O,EAAE6O,gBAAvC,EAAyD,KAAzD,EAAgE,IAAhE,CAAtB,CAAhB,CAAtB;AACAS,yBAAa,CAACpY,EAAEuY,mBAAF,CAAsB,OAAtB,EAA+B,CAACvY,EAAEwY,kBAAF,CAAqBC,aAArB,EAAoChE,cAApC,CAAD,CAA/B,CAAD,CAAb;AACA8C,yBAAavL,OAAb,CAAqB+H,mBAAmB;AACtC,kBAAIA,gBAAgB7Q,IAAhB,IAAwB6Q,gBAAgB4D,gBAA5C,EAA8D;AAC5DS,2BAAWnU,IAAX,CAAgBjE,EAAEkU,mBAAF,CAAsBlU,EAAEmU,oBAAF,CAAuB,GAAvB,EAA4BJ,gBAAgB7Q,IAA5C,EAAkD6Q,gBAAgB4D,gBAAlE,CAAtB,CAAhB;AACD;AACF,aAJD;AAKD,WARM,MAQA;AACLS,yBAAa,CAAC3D,cAAD,CAAb;AACD;AACDrC,kBAAQA,QAAQ3R,MAAR,GAAiB,CAAzB,EAA4BiY,mBAA5B,CAAgDN,UAAhD;AACD;;AAED,cAAMO,aAAN,GAAsB;AACpB,gBAAMjI,aAAa,KAAKA,UAAxB;AACA,gBAAMkI,cAAc,KAAKxX,UAAL,CAAgBuP,cAAhB,CAA+B,CAAC,EAAE1Q,OAAOD,CAAT,EAAYE,QAAZ,EAAD,MAA6B;AAC9E0Q,qBAAS;AACPrP,uBAASP,eAAe;AACtB,sBAAM;AACJ+C,+BADI;AAEJyT,sCAFI;AAGJtB;AAHI,oBAIF,KAAK2C,sBAAL,CAA4B7X,WAA5B,CAJJ;;AAMA,sBAAMmF,cAAcpC,cAAcpD,GAAd,CAAkB,KAAKuF,iBAAvB,EAA0C/B,IAA1C,EAApB;AACA,oBAAI8R,oBAAoBlS,cAAc,CAAd,EAAiB4E,IAAjB,CAAsB/G,UAAU;AACtD,yBAAOA,OAAOsB,IAAP,CAAYuH,IAAZ,IAAoB,aAA3B;AACD,iBAFuB,CAAxB;AAGA,oBAAIgN,iBAAiB,KAAKf,aAAL,CAAmB3S,aAAnB,CAArB;AACA,oBAAI,CAACkS,iBAAL,EAAwB;AACtBA,sCAAoBlS,cAAcA,cAActD,MAAd,GAAuB,CAArC,CAApB;AACD,iBAFD,MAEO;AACLgX,mCAAiBxB,kBAAkB/S,IAAlB,CAAuBgV,MAAxC;AACD;AACD,sBAAM5B,gBAAgB,KAAKA,aAAL,CAAmBvS,aAAnB,CAAtB;AACA,sBAAM+U,aAAa,KAAK9C,cAAL,CAAoB7P,WAApB,EAAiC8P,iBAAjC,EAAoDC,gBAApD,CAAnB;AACA,sBAAMqB,eAAe,KAAKV,gBAAL,CAAsB1Q,WAAtB,EAAmC8P,iBAAnC,EAAsDC,gBAAtD,CAArB;AACA,qBAAKmB,YAAL,CAAkBtT,aAAlB,EAAiC,CAAC,GAAG,IAAIiD,GAAJ,CAAQ8R,UAAR,CAAJ,CAAjC,EAA2DvB,YAA3D,EAAyEtB,iBAAzE,EAA4FuB,oBAA5F,EAAkHlB,aAAlH,EAAiImB,cAAjI;AACD;AAtBM;AADqE,WAA7B,CAA/B,CAApB;AA0BA,eAAKrW,UAAL,GAAkBwX,YAAYvX,IAA9B;AACA,eAAKyP,QAAL,CAAcJ,UAAd;AACA,gBAAMqI,gBAAgB,EAAtB;AACA,eAAK/X,WAAL,CAAiBsB,QAAjB,CAA0B;AACxByD,uBAAWvE,IAAX,EAAiB;AACf,kBAAIA,KAAK0B,IAAL,CAAU+C,IAAV,IAAkB,uCAAtB,EAA+D;AAC7D8S,8BAAc9U,IAAd,CAAmBzC,IAAnB;AACD;AACF;AALuB,WAA1B;AAOA,eAAKmE,WAAL,CAAiBoT,aAAjB;AACD;;AAED;;AAEAF,+BAAuB7X,WAAvB,EAAoCgY,SAAS,KAA7C,EAAoD;AAClD,cAAIjV,gBAAgB,KAAKK,qBAAL,CAA2BpD,WAA3B,CAApB;AACA,cAAIwW,uBAAuB,KAA3B;;AAEA,cAAIzT,cAActD,MAAd,IAAwB,CAA5B,EAA+B;AAC7B,gBAAIwY,cAAc,KAAKxU,sBAAL,CAA4BzD,WAA5B,CAAlB;AACA,gBAAIiY,YAAYxY,MAAZ,GAAqB,CAAzB,EAA4B;AAC1B,kBAAI,CAACuY,MAAL,EAAa/M,OAAOyF,IAAP,CAAY,2FAAZ;AACb;AACD,aAHD,MAGO,IAAIuH,YAAYxY,MAAZ,IAAsB,CAA1B,EAA6B;AAClC,kBAAI,CAACuY,MAAL,EAAa/M,OAAOyF,IAAP,CAAY,gDAAZ;AACb;AACD,aAHM,MAGA;AACL3N,8BAAgBkV,WAAhB;AACAzB,qCAAuB,IAAvB;AACD;AACF;;AAED,gBAAMtB,mBAAmBnS,cAAcpD,GAAd,CAAkBa,QAAQ;AACjD,mBAAO/B,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAAP;AACD,WAFwB,CAAzB;AAGA,iBAAO;AACLuE,yBADK;AAELyT,gCAFK;AAGLtB;AAHK,WAAP;AAKD;;AAED,cAAMgD,kCAAN,GAA2C;AACzC,gBAAM3V,YAAY,KAAK7C,cAAvB;AACA,cAAIyY,OAAO,KAAX;;AAEA,gBAAMzI,aAAa,KAAKA,UAAxB;;AAEA,cAAI0I,yBAAJ;AACA,gBAAMC,MAAM,KAAKjY,UAAL,CAAgBuP,cAAhB,CAA+B,CAAC,EAAE1Q,OAAOD,CAAT,EAAD,MAAmB;AAC5D4Q,qBAAS;AACPhM,0BAAYpD,QAAQ;AAClB,oBAAI,CAAC2X,IAAL,EAAW;AACT,wBAAMG,iBAAiB,KAAKxV,qBAAL,CAA2BtC,IAA3B,EAAiC+B,SAAjC,CAAvB;AACA,sBAAI+V,cAAJ,EAAoB;AAClBF,gDAA4B5X,KAAK+X,eAAL,EAA5B;;AAEA/X,yBAAKmH,IAAL,CAAUoP,KAAK;AACb,4BAAM9S,aAAa8S,EAAE9S,UAArB;AACA,0BAAI,CAACA,UAAL,EAAiB;AACf,+BAAO,KAAP;AACD;;AAED,+BAASuU,WAAT,CAAqBpI,IAArB,EAA2B;AACzB,4BAAI,CAACA,KAAKlO,IAAV,EAAgB,OAAO,KAAP;;AAEhB,4BAAIkO,KAAK7M,gBAAL,EAAJ,EAA6B;AAC3B,iCAAO,KAAP;AACD;;AAED,8BAAMkV,aAAa,EAAnB;AACA,4BAAIrI,KAAK9M,WAAL,EAAJ,EAAwB;AACtBmV,qCAAWxV,IAAX,CAAgBmN,KAAKlO,IAArB;AACA,gCAAMwW,YAAY1Z,EAAE8T,cAAF,CAAiB2F,UAAjB,CAAlB;AACArI,+BAAK2E,WAAL,CAAiB2D,SAAjB;AACA,iCAAO,IAAP;AACD,yBALD,MAKO,IAAItI,KAAKnM,UAAL,CAAgB0U,yBAAhB,MAA+CvI,KAAK1M,YAAL,EAAnD,EAAwE;AAC7E+U,qCAAWxV,IAAX,CAAgBjE,EAAE+T,eAAF,CAAkB3C,KAAKlO,IAAvB,CAAhB;AACA,gCAAMwW,YAAY1Z,EAAE8T,cAAF,CAAiB2F,UAAjB,CAAlB;AACArI,+BAAK2E,WAAL,CAAiB2D,SAAjB;AACA,iCAAO,IAAP;AACD,yBALM,MAKA;AACL,gCAAM,IAAIE,KAAJ,CAAU,yCAAV,CAAN;AACD;AACF;;AAED,4BAAMC,iBAAiBrY,KAAK+X,eAAL,EAAvB;AACA,4BAAMO,gBAAgB/B,EAAEwB,eAAF,EAAtB;AACA,0BAAIxB,EAAEgC,SAAF,KAAgB,MAAhB,KAA2B9U,WAAW+U,KAAX,MAAsB/U,WAAWgV,OAAX,EAAjD,CAAJ,EAA4E;AAC1E,8BAAMC,eAAeV,YAAYzB,CAAZ,CAArB;AACA,4BAAImC,YAAJ,EAAkB;AAChBd,sDAA4BU,gBAAgB,UAAhB,GAA6BD,eAAeM,OAAf,CAAuBL,aAAvB,EAAsC,EAAtC,CAAzD;AACD;AACD,+BAAO,IAAP;AACD;AACD,0BAAI/B,EAAEgC,SAAF,KAAgB,MAAhB,IAA0B9U,WAAWmQ,UAAX,EAA9B,EAAuD;AACrD,8BAAM8E,eAAeV,YAAYzB,CAAZ,CAArB;AACA,4BAAImC,YAAJ,EAAkB;AAChBd,sDAA4BU,gBAAgB,mBAAhB,GAAsCD,eAAeM,OAAf,CAAuBL,aAAvB,EAAsC,EAAtC,CAAlE;AACD;AACD,+BAAO,IAAP;AACD;AACD,0BAAI,CAAC/B,EAAEgC,SAAF,KAAgB,YAAhB,IAAgChC,EAAEgC,SAAF,KAAgB,WAAjD,KAAiE9U,WAAWmV,aAAX,EAArE,EAAiG;AAC/F,8BAAMF,eAAeV,YAAYzB,CAAZ,CAArB;AACA,4BAAImC,YAAJ,EAAkB;AAChBd,sDAA4BU,gBAAgB,UAAhB,GAA6BD,eAAeM,OAAf,CAAuBL,aAAvB,EAAsC,EAAtC,CAAzD;AACD;AACD,+BAAO,IAAP;AACD;AACF,qBApDD;;AAsDAX,2BAAO,IAAP;AACD;AACF;AACF;AAhEM;AADmD,WAAnB,CAA/B,CAAZ;;AAqEA,cAAI,CAACC,yBAAL,EAAgC;AAC9BnN,mBAAOyF,IAAP,CAAY,iCAAZ;AACA;AACD;;AAED,gBAAM2I,wBAAwB,EAA9B;AACA,gBAAMC,kBAAkBjB,IAAIhY,IAAJ,CAASsP,cAAT,CAAwB,CAAC,EAAE1Q,OAAOD,CAAT,EAAYE,QAAZ,EAAD,MAA6B;AAC3E0Q,qBAAS;AACPrP,uBAASP,eAAe;AACtB,sBAAMQ,OAAO,KAAK+Y,yBAAL,CAA+BvZ,WAA/B,EAA4CoY,yBAA5C,CAAb;AACA,oBAAI9Q,QAAQ,EAAZ;AACA9G,qBAAKc,QAAL,CAAc;AACZyD,6BAAWgS,CAAX,EAAc;AACZzP,6BAAS,MAAMyP,EAAE7U,IAAF,CAAO+C,IAAtB;AACD;AAHW,iBAAd;AAKA,oBAAIqC,MAAM7H,MAAN,GAAe,CAAnB,EAAsB;AACpB;AACA6H,0BAAQA,MAAMkF,SAAN,EAAR;AACD,iBAHD,MAGO;AACLlF,0BAAQ9G,KAAK8E,KAAL,CAAWkU,qBAAX,CAAiC,MAAjC,EAAyCvU,IAAjD;AACD;AACD,sBAAMI,aAAarG,EAAE+F,UAAF,CAAauC,KAAb,CAAnB;AACA,sBAAMmS,OAAOva,SAAS,kBAAT,EAA6B;AACxCwa,sBAAIrU,UADoC;AAExCsU,wBAAMnZ,KAAK0B;AAF6B,iBAA7B,CAAb;;AAKA,oBAAI0X,WAAW5a,EAAE+F,UAAF,CAAauC,KAAb,CAAf;;AAEA9G,qBAAKuU,WAAL,CAAiB6E,QAAjB;AACA,sBAAMC,sBAAsBrZ,KAAKsZ,kBAAL,GAA0BC,YAA1B,CAAuCN,IAAvC,EAA6C,CAA7C,CAA5B;AACA,sBAAMO,gCAAgCH,oBAAoBI,GAApB,CAAwB,cAAxB,EAAwC,CAAxC,EAA2CA,GAA3C,CAA+C,IAA/C,CAAtC;;AAEAZ,sCAAsBpW,IAAtB,CAA2B+W,8BAA8BzB,eAA9B,EAA3B;AACAc,sCAAsBpW,IAAtB,CAA2BzC,KAAK+X,eAAL,EAA3B;AACD;AA7BM;AADkE,WAA7B,CAAxB,CAAxB;AAiCA,eAAKnY,UAAL,GAAkBkZ,gBAAgBjZ,IAAlC;;AAEA,gBAAM0X,gBAAgB,KAAKmC,qBAAL,CAA2Bb,qBAA3B,CAAtB;;AAEA,eAAK1U,WAAL,CAAiBoT,aAAjB;AACA,eAAKjI,QAAL,CAAcJ,UAAd;AACD;;AAED,cAAMyK,kCAAN,GAA2C;AACzC,gBAAM5X,YAAY,KAAK7C,cAAvB;AACA,cAAIyY,OAAO,KAAX;;AAEA,gBAAMzI,aAAa,KAAKA,UAAxB;;AAEA,cAAI0I,yBAAJ;AACA,gBAAMC,MAAM,KAAKjY,UAAL,CAAgBuP,cAAhB,CAA+B,OAAO;AAChDC,qBAAS;AACPhM,0BAAYpD,QAAQ;AAClB,oBAAI,CAAC2X,IAAL,EAAW;AACT,wBAAMG,iBAAiB,KAAKxV,qBAAL,CAA2BtC,IAA3B,EAAiC+B,SAAjC,CAAvB;AACA,sBAAI+V,cAAJ,EAAoB;AAClBF,gDAA4B5X,KAAK+X,eAAL,EAA5B;AACAJ,2BAAO,IAAP;AACD;AACF;AACF;AATM;AADuC,WAAP,CAA/B,CAAZ;;AAcA,cAAI,CAACC,yBAAL,EAAgC;AAC9BnN,mBAAOyF,IAAP,CAAY,gCAAZ;AACA;AACD;;AAED,gBAAM2I,wBAAwB,EAA9B;AACA,gBAAMC,kBAAkBjB,IAAIhY,IAAJ,CAASsP,cAAT,CAAwB,CAAC,EAAEzQ,QAAF,EAAD,MAAmB;AACjE0Q,qBAAS;AACPrP,uBAASP,eAAe;AACtB,sBAAMQ,OAAO,KAAK+Y,yBAAL,CAA+BvZ,WAA/B,EAA4CoY,yBAA5C,CAAb;AACA,sBAAMgC,KAAKlb,SAAS,mBAAT,EAA8B;AACvCmb,wBAAM7Z,KAAK0B;AAD4B,iBAA9B,EAERoY,UAFH;;AAIA9Z,qBAAKuU,WAAL,CAAiBqF,EAAjB;;AAEAf,sCAAsBpW,IAAtB,CAA2BzC,KAAK+X,eAAL,EAA3B;AACD;AAVM;AADwD,WAAnB,CAAxB,CAAxB;AAcA,eAAKnY,UAAL,GAAkBkZ,gBAAgBjZ,IAAlC;;AAEA,gBAAM0X,gBAAgB,KAAKmC,qBAAL,CAA2Bb,qBAA3B,CAAtB;;AAEA,eAAK1U,WAAL,CAAiBoT,aAAjB;AACA,eAAKjI,QAAL,CAAcJ,UAAd;AACD;;AAED;;AAEA,YAAItP,UAAJ,GAAiB;AACf,iBAAO,KAAKf,YAAL,CAAkBgB,IAAzB;AACD;AACD,YAAID,UAAJ,CAAewM,IAAf,EAAqB;AACnB,eAAKvN,YAAL,CAAkBgB,IAAlB,GAAyBuM,IAAzB;AACA,eAAKtN,WAAL;AACA,iBAAO,KAAKD,YAAL,CAAkBgB,IAAzB;AACD;;AAED,YAAIqP,UAAJ,GAAiB;AACf,iBAAO,KAAKrQ,YAAL,CAAkBqQ,UAAzB;AACD;;AAEDI,iBAASJ,UAAT,EAAqB;AACnB,eAAKrQ,YAAL,CAAkBqQ,UAAlB;AACD;;AAED;;AAEA2F,mBAAW7U,IAAX,EAAiBhB,aAAa,IAA9B,EAAoC;AAClC,cAAI,CAACA,UAAL,EAAiB;AACfA,yBAAa,KAAKD,eAAlB;AACD;AACD,gBAAMgb,YAAY9b,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAAlB;AACA,eAAK,MAAM+D,SAAX,IAAwB/C,UAAxB,EAAoC;AAClC,gBAAI+C,UAAUG,aAAV,CAAwB6X,SAAxB,CAAJ,EAAwC;AACtC,qBAAO,IAAP;AACD;AACF;AACD,iBAAO,KAAP;AACD;;AAEDzX,8BAAsBtC,IAAtB,EAA4B+B,SAA5B,EAAuC;AACrC,iBAAOA,UAAUwB,OAAV,CAAkBtF,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,CAAlB,CAAP;AACD;;AAED+a,kCAA0BvZ,WAA1B,EAAuCyP,QAAvC,EAAiD;AAC/C,cAAIjP,OAAOR,WAAX;AACA,gBAAMwa,MAAM,iCAAZ;AACA,cAAIC,MAAJ;AACA,iBAAO,CAACA,SAASD,IAAIE,IAAJ,CAASjL,QAAT,CAAV,MAAkC,IAAzC,EAA+C;AAC7C,gBAAIkL,OAAOF,OAAO,CAAP,CAAX;AACA,gBAAIE,KAAKC,UAAL,CAAgB,GAAhB,CAAJ,EAA0B;AACxBD,qBAAOA,KAAKxB,OAAL,CAAa,GAAb,EAAkB,EAAlB,CAAP;AACA3Y,qBAAOA,KAAKyZ,GAAL,CAASU,IAAT,CAAP;AACD,aAHD,MAGO;AACLA,qBAAOA,KAAKxB,OAAL,CAAa,SAAb,EAAwB,EAAxB,CAAP;AACAwB,qBAAOE,SAASF,IAAT,CAAP;AACAna,qBAAOA,KAAKma,IAAL,CAAP;AACD;AACF;;AAED,iBAAOna,IAAP;AACD;;AAED0Z,8BAAsBY,aAAtB,EAAqC;AACnC,gBAAM3S,QAAQ,EAAd;;AAEA,eAAK/H,UAAL,CAAgBE,aAAhB,CAA8B;AAC5BC,qBAASC,QAAQ;AACfsa,4BAAc9P,OAAd,CAAsByE,YAAY;AAChCtH,sBAAMlF,IAAN,CAAW,KAAKsW,yBAAL,CAA+B/Y,IAA/B,EAAqCiP,QAArC,CAAX;AACD,eAFD;AAGD;AAL2B,WAA9B;;AAQA,iBAAOtH,KAAP;AACD;;AAED,cAAMoC,uBAAN,CAA8BiJ,UAA9B,EAA0C;AACxC,cAAIjM,QAAQ,MAAM1I,UAAUmP,OAAV,EAAlB;;AAEA;AACA,cAAI+M,kBAAkB,MAAMxT,MAAM2G,EAAN,CAASU,OAAT,CAAiBvH,MAAjB,CAAwBqD,MAAM;AACxD,mBAAOA,GAAGsQ,OAAH,CAAW5M,IAAX,CAAgB6M,MAAMA,GAAGhW,IAAH,IAAWuO,UAAjC,CAAP;AACD,WAF2B,EAEzBnF,OAFyB,EAA5B;;AAIA;AACA,cAAI6M,kBAAkB,MAAM3T,MAAM2G,EAAN,CAASiN,OAAT,CAAiBC,KAAjB,CAAuB,KAAvB,EAA8BC,KAA9B,CAAoCN,gBAAgBpb,GAAhB,CAAoB+K,MAAMA,GAAGC,GAA7B,CAApC,EAAuE0D,OAAvE,EAA5B;;AAEA;AACA,cAAIiN,YAAYP,gBAAgB1T,MAAhB,CAAuBqD,MAAM;AAC3C,mBAAOwQ,gBAAgB9M,IAAhB,CAAqBmN,KAAKA,EAAE5Q,GAAF,IAASD,GAAGC,GAAZ,IAAmB4Q,EAAE3M,OAAF,CAAUR,IAAV,CAAeoN,OAAOA,OAAO9Q,GAAGzF,IAAhC,CAA7C,CAAP;AACD,WAFe,CAAhB;AAGA,iBAAOqW,UAAUjU,MAAV,CAAiBiK,MAAMA,GAAG3G,GAAH,CAAO7B,KAAP,CAAa2S,UAAb,CAAvB,CAAP,CAfwC,CAeiB;AAC1D;;AAED,cAAM5Q,qBAAN,CAA4B2I,UAA5B,EAAwC;AACtC,cAAIjM,QAAQ,MAAM1I,UAAUmP,OAAV,EAAlB;AACA,cAAIsN,YAAY,MAAM/T,MAAM2G,EAAN,CAASiN,OAAT,CAAiB9T,MAAjB,CAAwBqU,OAAO;AACnD,mBAAOA,IAAI/M,SAAJ,CAAcP,IAAd,CAAmB6M,MAAMA,MAAMzH,UAA/B,CAAP;AACD,WAFqB,EAEnBnF,OAFmB,EAAtB;AAGA,iBAAOiN,UAAU3b,GAAV,CAAcnB,OAAOA,IAAImM,GAAzB,EAA8BtD,MAA9B,CAAqCsD,OAAOA,IAAI7B,KAAJ,CAAU2S,UAAV,CAA5C,CAAP;AACD;;AAID;;AAEAE,yBAAiBlM,QAAjB,EAA2B;AACzB,cAAImM,SAAJ;AACF,eAAK5b,WAAL,CAAiBsB,QAAjB,CAA0B;AACzBua,2BAAerb,IAAf,EAAqB;AAChB,kBAAI,CAAC/B,MAAM+B,KAAK0B,IAAL,CAAU1D,GAAhB,EAAqBsd,QAArB,CAA8BrM,QAA9B,CAAL,EAA8C;AAC5CjP,qBAAK0C,IAAL;AACD,eAFD,MAEO,IAAI6Y,QAAQvb,IAAR,CAAJ,EAAmB;AACxBob,4BAAYpb,IAAZ;AACAA,qBAAKgB,IAAL;AACL;AACD;AARwB,WAA1B;AAUE,iBAAOoa,SAAP;AACD;;AAED,YAAII,6BAAJ,GAAoC;AAClC,iBAAO,KAAKhc,WAAL,CAAiBkC,IAAjB,CAAsB+Z,UAAtB,CAAiC7N,IAAjC,CAAsClM,QAAQ;AACnD,mBAAOA,KAAKoF,KAAL,CAAWA,KAAX,KAAqB,cAA5B;AACD,WAFM,CAAP;AAGD;;AAED4U,2BAAmB;AACjB,cAAI,KAAKrb,kBAAT,EAA6B,OAAO,IAAP;AAC7B,cAAI,CAAC,KAAKb,WAAN,IAAqB,CAAC,KAAKgc,6BAA/B,EAA8D,OAAO,KAAP;AAC9D,cAAI;AACF,iBAAKG,MAAL;AACD,WAFD,CAEE,OAAO1b,GAAP,EAAY;AACZ2b,oBAAQC,KAAR,CAAc,+BAAd,EAA+C5b,GAA/C;AACA,mBAAO,KAAP;AACD;AACD,iBAAO,IAAP;AACD;;AAED0b,iBAAS;AACP,cAAI3U,OAAO,IAAX;AACF,eAAK7G,QAAL,CAAcL,aAAd,CAA4B;AAC3BiB,kBAAMf,IAAN,EAAY;AACXA,mBAAK0B,IAAL,CAAUoa,KAAV,GAAkB;AACjB;AACA;AACA;AACAC,yBAAS,CAJQ;AAKjB;AACAC,+BAAe;AANE,eAAlB;AAQA;AAV0B,WAA5B;;AAaA;AACA,eAAK7b,QAAL,CAAcL,aAAd,CAA4B;AACxBmc,kBAAMjc,IAAN,EAAY;AACdkc,qBAAOC,OAAP,CAAenc,KAAK8E,KAAL,CAAWsE,QAA1B,EAAoCoB,OAApC,CAA4C,CAAC,CAAC4R,KAAD,EAAQlX,OAAR,CAAD,KAAsB;AACjEA,wBAAQO,cAAR,CAAuB+E,OAAvB,CAA+BxK,QAAQ;AACtCA,uBAAK0B,IAAL,CAAUoa,KAAV,CAAgB5W,OAAhB,GAA0BA,OAA1B;AACA,iBAFD;AAGA,eAJD;AAKA;AAP0B,WAA5B;;AAUA,eAAKmX,wBAAL;;AAEE,eAAKC,mBAAL;;AAEF,eAAK9c,WAAL,CAAiBsB,QAAjB,CAA0B;AACzBsC,uBAAWmZ,IAAX,EAAiB;AAChBvV,mBAAKwV,4BAAL,CAAkCD,IAAlC;AACA;AAHwB,WAA1B;;AAME,eAAKlc,kBAAL,GAA0B,IAA1B;AACF;;AAEA;AACAgc,mCAA0B;AACxB,cAAIrV,OAAO,IAAX;AACA,eAAKxH,WAAL,CAAiBsB,QAAjB,CAA0B;AAC3B2b,6BAAiBF,IAAjB,EAAuB;AACtB,kBAAIA,KAAK7a,IAAL,CAAUgb,QAAd,EAAwB;AACxB,kBAAI,CAACH,KAAK9Y,UAAL,CAAgBkZ,sBAAhB,EAAL,EAA+C;AAC3C,kBAAIC,aAAa5V,KAAK6V,aAAL,CAAmBN,KAAK9Y,UAAxB,CAAjB;;AAEJ,kBAAIqZ,MAAMP,KAAK9C,GAAL,CAAS,QAAT,CAAV;AACA,kBAAIsD,SAASD,IAAIpb,IAAJ,CAASoa,KAAT,CAAe5W,OAAf,IAA0B,MAAvC;AACA,kBAAI6N,WAAWwJ,KAAK9C,GAAL,CAAS,UAAT,EAAqB/X,IAArB,CAA0B+C,IAAzC;;AAEA,kBAAIuY,QAAQhW,KAAK1G,iBAAL,CAAuBmZ,GAAvB,CAA2B1G,QAA3B,CAAZ;AACA,kBAAI,CAACiK,KAAL,EAAY;AACX;AACA,oBAAIC,SAAS,IAAI1c,GAAJ,EAAb;;AAEA0c,uBAAOC,GAAP,CAAWH,MAAX,EAAmB,CAACH,UAAD,CAAnB;AACA5V,qBAAK1G,iBAAL,CAAuB4c,GAAvB,CAA2BnK,QAA3B,EAAqCkK,MAArC;AACA,eAND,MAMO;AACN,oBAAIE,WAAWH,MAAMvD,GAAN,CAAUsD,MAAV,CAAf;AACA,oBAAI,CAACI,QAAL,EAAe;AACdA,6BAAW,EAAX;AACAH,wBAAME,GAAN,CAAUH,MAAV,EAAkBI,QAAlB;AACA;AACDA,yBAAS1a,IAAT,CAAcma,UAAd;AACA;AACD;AAzB0B,WAA1B;AA2BD;;AAEDN,8BAAqB;AACrB;AACE,eAAKnc,QAAL,CAAcL,aAAd,CAA4B;AAC1B,uDAA2CE,IAA3C,EAAiD;AAC/CA,mBAAK0B,IAAL,CAAUoa,KAAV,CAAgBsB,eAAhB,GAAkCA,gBAAgBpd,IAAhB,CAAlC;AACA,oBAAMqd,kBAAkBrd,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBuB,eAAhB,GAAkC,EAA1D;AACA,oBAAMC,UAAUtd,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBwB,OAAhB,GAA0B,IAAI/c,GAAJ,EAA1C;AACA,oBAAMgd,UAAUvd,KAAK0B,IAAL,CAAUoa,KAAV,CAAgByB,OAAhB,GAA0B,EAA1C;;AAEAvd,mBAAKc,QAAL,CAAc;AACZ2b,iCAAiBF,IAAjB,EAAuB;AACrB,sBAAIA,KAAK9Y,UAAL,CAAgBkZ,sBAAhB,EAAJ,EAA8C;AAC9C,sBAAIa,UAAUjB,KAAK9C,GAAL,CAAS,QAAT,EAAmB/X,IAAjC;AACA,sBAAIqR,WAAWwJ,KAAK9C,GAAL,CAAS,UAAT,EAAqB/X,IAArB,CAA0B+C,IAAzC;;AAEA,sBAAIuY,QAAQM,QAAQ7D,GAAR,CAAY+D,OAAZ,CAAZ;AACA,sBAAI,CAACR,KAAL,EAAY;AACVM,4BAAQJ,GAAR,CAAYM,OAAZ,EAAqB,IAAIhY,GAAJ,CAAQ,CAACuN,QAAD,CAAR,CAArB;AACD,mBAFD,MAEO;AACLiK,0BAAMS,GAAN,CAAU1K,QAAV;AACD;AACF;AAZW,eAAd;;AAeA/S,mBAAKc,QAAL,CAAc;AACZ4c,gCAAgBC,GAAhB,EAAqB;AACnB,sBAAIA,IAAIC,GAAJ,CAAQ,UAAR,CAAJ,EAAyB;AACvBL,4BAAQ9a,IAAR,CAAakb,IAAIlE,GAAJ,CAAQ,UAAR,CAAb;AACD;AACF,iBALW;AAMZ4B,+BAAewC,IAAf,EAAqB;AACnBR,kCAAgB5a,IAAhB,CAAqBob,IAArB;AACD;AARW,eAAd;AAUD;AAhCyB,WAA5B;AAkCD;;AAED;;;;;;;AAODrB,qCAA6Bxc,IAA7B,EAAmC;AAClC,cAAIA,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBE,aAAhB,IAAiC,CAArC,EAAwC;AACvC,mBAAO,EAAP;AACA;;AAEDhc,eAAK0B,IAAL,CAAUoa,KAAV,CAAgBE,aAAhB,IAAiC,CAAjC;;AAEA,cAAIhc,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBgC,OAApB,EAA6B;AAC5B,mBAAO9d,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBgC,OAAvB;AACA;;AAED,cAAIA,UAAU,EAAd;AACE,cAAIC,kBAAkB,EAAtB;;AAEF,cAAI/d,KAAKge,kBAAL,EAAJ,EAA+B;AAC3BD,8BAAkB,CAAC,EAAC3H,kBAAiBpW,IAAlB,EAAwBoJ,UAAS,IAAI5D,GAAJ,EAAjC,EAAD,CAAlB;AAEH,WAHD,MAGO,IAAIxF,KAAKmD,YAAL,EAAJ,EAAyB;AAC5B,gBAAI,CAACnD,KAAKyD,UAAL,CAAgBwa,kBAAhB,EAAL,EAA2C;AACzC,kBAAI/Y,UAAUlF,KAAK0B,IAAL,CAAUoa,KAAV,CAAgB5W,OAA9B;AACA,kBAAIA,OAAJ,EAAa;AACX,iBAACA,QAAQlF,IAAT,EAAe,GAAGkF,QAAQQ,kBAA1B,EAA8C8E,OAA9C,CAAsD2F,QAAQ;AAC5D,uBAAKqM,4BAAL,CAAkCrM,IAAlC;AACA2N,0BAAQrb,IAAR,CAAa0N,KAAKzO,IAAL,CAAUoa,KAAV,CAAgBgC,OAA7B;AACA3N,uBAAKzO,IAAL,CAAUoa,KAAV,CAAgBiC,eAAhB,CAAgCvT,OAAhC,CAAwCsS,OAAM;AAC5CA,wBAAI1T,QAAJ,CAAaqU,GAAb,CAAiBvY,OAAjB;AACA6Y,oCAAgBtb,IAAhB,CAAqBqa,GAArB;AACD,mBAHD;AAID,iBAPD;AAQD;AACF;AACF,WAdI,MAcE,IAAI9c,KAAK2c,sBAAL,MAAiC3c,KAAKke,oBAAL,EAArC,EAAkE;AACvE,gBAAIC,MAAM,KAAKtB,aAAL,CAAmB7c,IAAnB,CAAV;AACH,iBAAKwc,4BAAL,CAAkC2B,GAAlC;AACAL,sBAAUK,IAAIzc,IAAJ,CAASoa,KAAT,CAAegC,OAAzB;AACGC,8BAAkBI,IAAIzc,IAAJ,CAASoa,KAAT,CAAeiC,eAAjC;AACD,WALM,MAKA,IAAI/d,KAAK4T,UAAL,EAAJ,EAAuB;AAC/BkK,sBAAU,CAAC9d,IAAD,CAAV;AACA,WAFQ,MAEF,IAAIA,KAAKoe,uBAAL,EAAJ,EAAoC;AAC1C,aAACpe,KAAKyZ,GAAL,CAAS,YAAT,CAAD,EAAyBzZ,KAAKyZ,GAAL,CAAS,WAAT,CAAzB,EAAgDjP,OAAhD,CAAwD+R,QAAQ;AAC/D,mBAAKC,4BAAL,CAAkCD,IAAlC;AACAuB,sBAAQrb,IAAR,CAAa8Z,KAAK7a,IAAL,CAAUoa,KAAV,CAAgBgC,OAA7B;AACIC,8BAAgBtb,IAAhB,CAAqB8Z,KAAK7a,IAAL,CAAUoa,KAAV,CAAgBiC,eAArC;AACJ,aAJD;AAKA,WANM,MAMA,IAAI/d,KAAKqe,gBAAL,EAAJ,EAA6B;AACnC,kBAAM7P,SAASxO,KAAKyZ,GAAL,CAAS,QAAT,CAAf;AACA,gBAAI6E,kBAAkB,EAAtB;AACA,iBAAK9B,4BAAL,CAAkChO,MAAlC;AACAA,mBAAO9M,IAAP,CAAYoa,KAAZ,CAAkBgC,OAAlB,CAA0BtT,OAA1B,CAAkC+T,QAAQ;AACzC,mBAAK/B,4BAAL,CAAkC+B,IAAlC;AACA,oBAAM3O,OAAO2O,KAAK9E,GAAL,CAAS,MAAT,CAAb;AACA,kBAAI,CAAC7J,KAAK7M,gBAAL,EAAL,EAA8B;AAC7B;AACA,qBAAKyZ,4BAAL,CAAkC5M,IAAlC;AACAkO,wBAAQrb,IAAR,CAAamN,KAAKlO,IAAL,CAAUoa,KAAV,CAAgBgC,OAA7B;AACA,eAJD,MAIO;AACNS,qBAAK7c,IAAL,CAAUoa,KAAV,CAAgByB,OAAhB,CAAwB/S,OAAxB,CAAgC+H,mBAAmB;AAClD,uBAAKiK,4BAAL,CAAkCjK,eAAlC;AACAuL,0BAAQrb,IAAR,CAAa8P,gBAAgB7Q,IAAhB,CAAqBoa,KAArB,CAA2BgC,OAAxC;AACMC,kCAAgBtb,IAAhB,CAAqB8P,gBAAgB7Q,IAAhB,CAAqBoa,KAArB,CAA2BiC,eAAhD;AACN,iBAJD;AAKA;AACD;AACAO,8BAAgB7b,IAAhB,CAAqB8b,IAArB;AACA,aAhBD;AAiBAve,iBAAK0B,IAAL,CAAUoa,KAAV,CAAgBwC,eAAhB,GAAkCA,gBAAgB3b,IAAhB,EAAlC;AAEA,WAvBM,MAuBA,IAAI3C,KAAK6F,kBAAL,EAAJ,EAA+B;AACrC,kBAAM2X,UAAUxd,KAAKyZ,GAAL,CAAS,QAAT,CAAhB;AACA,iBAAK+C,4BAAL,CAAkCgB,OAAlC;;AAEA,gBAAI/M,MAAM+M,QAAQ9b,IAAR,CAAaoa,KAAb,CAAmBiC,eAAnB,CAAmCpb,IAAnC,EAAV;AACA8N,gBAAIjG,OAAJ,CAAYyP,UAAU;AACrB,mBAAKuE,aAAL,CAAmBxe,KAAKyZ,GAAL,CAAS,UAAT,EAAqB/X,IAArB,CAA0B+C,IAA7C,EAAmDwV,MAAnD,EAA2DzP,OAA3D,CAAmEoS,cAAc;AAChF,qBAAKJ,4BAAL,CAAkCI,UAAlC;AACAkB,wBAAQrb,IAAR,CAAama,WAAWlb,IAAX,CAAgBoa,KAAhB,CAAsBgC,OAAnC;AACKC,gCAAgBtb,IAAhB,CAAqBma,WAAWlb,IAAX,CAAgBoa,KAAhB,CAAsBiC,eAA3C;AACL,eAJD;AAKA,aAND;AAOA;AACC/d,eAAK0B,IAAL,CAAUoa,KAAV,CAAgBiC,eAAhB,GAAkCA,gBAAgBpb,IAAhB,EAAlC;AACF3C,eAAK0B,IAAL,CAAUoa,KAAV,CAAgBgC,OAAhB,GAA0BA,QAAQnb,IAAR,EAA1B;AACA;;AAEA;AACD6b,sBAAczL,QAAd,EAAwB+J,GAAxB,EAA6B;;AAE1B,cAAI7C,SAAS,EAAb;AACA,eAAKwE,gBAAL,CAAsB3B,IAAI1T,QAA1B,EAAoCoB,OAApC,CAA4CtF,WAAS;;AAEnD,gBAAIwZ,gBAAgB,KAAKpe,iBAAL,CAAuBmZ,GAAvB,CAA2B1G,QAA3B,KAAwC,IAAIxS,GAAJ,EAA5D;AACA,gBAAIoe,qBAAqBD,cAAcjF,GAAd,CAAkB,MAAlB,KAA6B,EAAtD;AACAkF,+BAAmBnU,OAAnB,CAA2BoS,cAAc3C,OAAOxX,IAAP,CAAYma,UAAZ,CAAzC;;AAEA,gBAAIO,WAAWuB,cAAcjF,GAAd,CAAkBvU,OAAlB,CAAf;AACA,gBAAIiY,QAAJ,EAAc;AACZA,uBAAS3S,OAAT,CAAiBoS,cAAc3C,OAAOxX,IAAP,CAAYma,UAAZ,CAA/B;AACD;AACF,WAVD;;AAYA;AACF,cAAIY,UAAUV,IAAI1G,gBAAlB,CAhB4B,CAgBQ;AAClC,cAAIoH,WAAWA,QAAQQ,kBAAR,EAAf,EAA4C;AAC1C,gBAAIvN,MAAM+M,QACP/D,GADO,CACH,YADG,EAEPtS,IAFO,CAEFnH,QAAQA,KAAKyZ,GAAL,CAAS,KAAT,EAAgB/X,IAAhB,CAAqB+C,IAArB,KAA8BsO,QAFpC,CAAV;AAGA,gBAAGtC,GAAH,EAAQ;AACN,kBAAIA,IAAImO,gBAAJ,EAAJ,EAA4B;AAC1B3E,uBAAOxX,IAAP,CAAYgO,IAAIgJ,GAAJ,CAAQ,OAAR,CAAZ;AACD,eAFD,MAEO,IAAIhJ,IAAIoO,cAAJ,EAAJ,EAA0B;AAC/B5E,uBAAOxX,IAAP,CAAYgO,GAAZ;AACD;AACF;AACF;AACH,iBAAOwJ,MAAP;AACA;;AAEA4C,sBAAc7c,IAAd,EAAoB;AAClB,cAAIA,KAAKie,kBAAL,EAAJ,EAA+B,OAAOje,IAAP;AAC/B,cAAIA,KAAK8e,qBAAL,EAAJ,EAAkC,OAAO9e,IAAP;AAClC,cAAIA,KAAK2c,sBAAL,EAAJ,EAAmC,OAAO3c,KAAKyZ,GAAL,CAAS,OAAT,CAAP;AACnC,cAAIzZ,KAAKke,oBAAL,EAAJ,EAAiC;AAC/B,kBAAMnW,KAAK/H,KAAKyZ,GAAL,CAAS,IAAT,CAAX;AACA,gBAAI1R,GAAGgX,SAAH,EAAJ,EAAoB,OAFW,CAEH;AAC5B,mBAAO/e,KAAKyZ,GAAL,CAAS,MAAT,CAAP;AACD;AACD;AACD;;AAGD;;;;;;;;;;AAUAgF,yBAAiBrV,QAAjB,EAA2B;;AAEzB;;;;AAIA,cAAI6Q,SAAS7Q,QAAb;AACAA,mBAASoB,OAAT,CAAiBtF,WAAS;AACxBA,oBAAQlF,IAAR,CAAa0B,IAAb,CAAkBoa,KAAlB,CAAwBiC,eAAxB,CAAwCvT,OAAxC,CAAgDsS,OAAK;AACnD,kBAAGA,IAAI1T,QAAP,EAAiB;AACf0T,oBAAI1T,QAAJ,CAAaoB,OAAb,CAAqB2F,QAAQ8J,OAAOwD,GAAP,CAAWtN,IAAX,CAA7B;AACD;AACF,aAJD;AAKD,WAND;;AAQA,iBAAO8J,MAAP;AACD;;AAEF;;;;AAIA+E,4BAAoBhf,IAApB,EAA0B;AACvB,cAAI,CAAC,KAAK0b,gBAAL,EAAL,EAA8B,OAAO,IAAIlW,GAAJ,EAAP;;AAE9B,cAAIxF,KAAK0B,IAAL,CAAUud,YAAV,IAA0B,IAA9B,EAAoC;AAClC,mBAAOjf,KAAK0B,IAAL,CAAUud,YAAjB;AACD;;AAEH,iBAAO,KAAKC,oBAAL,CAA0Blf,IAA1B,CAAP;AACA;;AAEDkf,6BAAqBlf,IAArB,EAA2B;AACxB,gBAAMgH,OAAO,IAAb;AACF,cAAI,CAAChH,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBC,OAAhB,IAA2B,CAA5B,KAAkC,CAAtC,EAAyC;AACxC,mBAAO/b,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBmD,YAAhB,IAAgC,IAAIzZ,GAAJ,EAAvC;AACA;;AAED,cAAIxF,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBmD,YAApB,EAAkC;AACjC;AACA,mBAAOjf,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBmD,YAAvB;AACA;;AAED,cAAIA,eAAe,IAAIzZ,GAAJ,CAAQ,CAAC,GAAG,KAAKiZ,gBAAL,CAAsBze,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBsB,eAAtC,CAAJ,EAA4Dje,GAA5D,CAAgE+F,WAAW,CAAC,GAAGA,QAAQQ,kBAAZ,CAA3E,EAA4G/C,IAA5G,EAAR,CAAnB;AACA3C,eAAK0B,IAAL,CAAUoa,KAAV,CAAgBuB,eAAhB,CAAgC7S,OAAhC,CAAwCyI,kBAAkB;AACzDA,2BAAevR,IAAf,CAAoBoa,KAApB,CAA0BwC,eAA1B,CAA0C9T,OAA1C,CAAkDgE,UAAU;AAC3D,kBAAIhQ,EAAEoV,UAAF,CAAapF,MAAb,CAAJ,EAA0B;AACzB,qBAAK0Q,oBAAL,CAA0B1Q,MAA1B,EAAkChE,OAAlC,CAA0C2U,OAAOF,aAAaxB,GAAb,CAAiB0B,GAAjB,CAAjD;AACA;;AAED,kBAAI3gB,EAAEme,sBAAF,CAAyBnO,MAAzB,CAAJ,EAAsC;AACrC,sBAAM1H,QAAQ,KAAK+V,aAAL,CAAmBrO,MAAnB,CAAd;AACA,oBAAIhQ,EAAEoV,UAAF,CAAa9M,KAAb,KAAuBtI,EAAE2Z,yBAAF,CAA4BrR,KAA5B,CAA3B,EAA+D;AAC9D,uBAAKoY,oBAAL,CAA0BpY,KAA1B,EAAiC0D,OAAjC,CAAyC2U,OAAOF,aAAaxB,GAAb,CAAiB0B,GAAjB,CAAhD;AACA;AACD;;AAED,kBAAI3gB,EAAE0f,oBAAF,CAAuB1P,MAAvB,CAAJ,EAAoC;AACnC;AACA;AACD,aAfD;AAgBA,WAjBD;;AAmBA,cAAIxO,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBwB,OAAhB,CAAwB8B,IAA5B,EAAkC;AACjC,iBAAK,MAAM,CAAC5B,OAAD,EAAU9W,OAAV,CAAX,IAAiC1G,KAAK0B,IAAL,CAAUoa,KAAV,CAAgBwB,OAAhB,CAAwBnB,OAAxB,EAAjC,EAAoE;AAC/D,kBAAI3d,EAAEsH,gBAAF,CAAmB0X,OAAnB,CAAJ,EAAiC;AACrC,mBAAK,MAAM6B,MAAX,IAAqB3Y,OAArB,EAA8B;AACtBM,qBAAKwX,aAAL,CAAmBa,MAAnB,EAA2B,EAACjW,UAAU,IAAI5D,GAAJ,CAAQ,CAACgY,QAAQ1B,KAAR,CAAc5W,OAAf,CAAR,CAAX,EAA3B,EAAyEsF,OAAzE,CAAiFoS,cAAc;AACrGqC,+BAAaxB,GAAb,CAAiBb,UAAjB;AACA,iBAFM;AAGP;AACD;AACD;AACD5c,eAAK0B,IAAL,CAAUoa,KAAV,CAAgBmD,YAAhB,GAA+BA,YAA/B;AACA,iBAAOA,YAAP;AACA;;AAEAK,kCAA0B;AACxB,iBAAO,KAAK9e,MAAL,KAAgB,KAAKA,MAAL,GAAc,KAAK+e,cAAL,EAA9B,CAAP;AACD;;AAEDA,yBAAiB;AACf,gBAAMC,WAAW,EAAjB;AACA,eAAKhgB,WAAL,CAAiBsB,QAAjB,CAA0B;AACxBua,2BAAerb,IAAf,EAAqB;AACnB,kBAAIub,QAAQvb,IAAR,CAAJ,EAAoB;AAClBwf,yBAAS/c,IAAT,CAAczC,IAAd;AACD;AACF;AALuB,WAA1B;AAOA,iBAAOwf,QAAP;AACD;;AAtwDkC;;yBAAhB7gB,e;;;;;;;;;;;;;;;;AA0wDrB;;AAEA,YAAM8gB,wBAAwB,OAA9B;;;;;;;;;;;;;;;AAEA,eAASrC,eAAT,CAAyBpd,IAAzB,EAA+B;AAC9B,cAAMoJ,WAAW,IAAI5D,GAAJ,EAAjB;AACAxF,aAAKc,QAAL,CAAc;AACb4e,+BAAqB3X,EAArB,EAAyB;AACxB,kBAAM4X,eAAe3f,KAAK8E,KAAL,CAAWE,UAAX,CAAsB+C,GAAGrG,IAAH,CAAQ+C,IAA9B,CAArB;AACA,gBAAI,CAACkb,YAAL,EAAmB;AACnB,kBAAMC,gBAAgB7X,GAAGjD,KAAH,CAASE,UAAT,CAAoB+C,GAAGrG,IAAH,CAAQ+C,IAA5B,CAAtB;AACA,gBAAIkb,iBAAiBC,aAArB,EAAoC;AACnCxW,uBAASqU,GAAT,CAAamC,aAAb;AACA;AACD;AARY,SAAd;AAUA,eAAOxW,QAAP;AACA;;AAED,eAASmS,OAAT,CAAiBvb,IAAjB,EAAuB;AACtB,eAAOxB,EAAE6f,gBAAF,CAAmBre,IAAnB,KACHxB,EAAE2E,YAAF,CAAenD,KAAK0B,IAAL,CAAU8M,MAAzB,CADG,IAEHxO,KAAK0B,IAAL,CAAU8M,MAAV,CAAiB/J,IAAjB,KAA0Bgb,qBAFvB,IAGH,CAACzf,KAAK8E,KAAL,CAAWC,UAAX,CAAsB0a,qBAAtB,EAA6C,IAA7C,CAHL;AAIA","file":"lively-code-mirror-ast-capabilities.js","sourcesContent":["import { loc, range } from 'utils';\n\nimport boundEval from 'src/client/bound-eval.js';\nimport FileIndex from \"src/client/fileindex.js\";\n\nimport babelDefault from 'systemjs-babel-build';\nconst babel = babelDefault.babel;\n\nconst t = babel.types;\nconst template = babel.template;\n\nimport { fileEnding, replaceFileEndingWith } from \"utils\";\n\nexport default class ASTCapabilities {\n\n  constructor(codeProvider) {\n    this.codeProvider = codeProvider;\n    this.codeChanged();\n  }\n\n  get selectionRanges() {\n    if (this.codeProvider.selections.length == 0) {\n      return this.firstSelection;\n    }\n    return this.codeProvider.selections.map(range);\n  }\n\n  get firstSelection() {\n    return range(this._getFirstSelectionOrCursorPosition());\n  }\n\n  _getFirstSelectionOrCursorPosition() {\n    if (this.codeProvider.selections.length == 0) {\n      return { anchor: this.codeProvider.cursor, head: this.codeProvider.cursor };\n    }\n    return this.codeProvider.selections[0];\n  }\n  \n  /*MD ## Navigation MD*/\n  /**\n   * Get the root path\n  */\n  get programPath() {\n    if (!this.myProgramPath && !this.parsingFailed) {\n      this.myProgramPath = this.programPathFor(this.sourceCode);\n      this.parsingFailed = !this.myProgramPath;\n    }\n    return this.myProgramPath;\n  }\n\n  programPathFor(code) {\n    var programPath = null;\n    try {\n      code.traverseAsAST({\n        Program(path) {\n          programPath = path;\n        }\n      });\n    } catch (err) {\n      return undefined;\n    }\n\n    return programPath;\n  }\n\n  get rootNode() {\n    return this.programPath && this.programPath.parent;\n  }\n\n  codeChanged() {\n    this.myProgramPath = undefined;\n    this.parsingFailed = null;\n    this.finishedEnrichment = false;\n    this.memberAssignments = new Map();\n    this.aexprs = undefined;\n  }\n\n  get canParse() {\n    if (this.parsingFailed == null) this.programPath;\n    return !this.parsingFailed;\n  }\n\n  /** \n   * Return first child in depth first search that satisfies a condition\n   */\n  nextPath(startingPath, isValid) {\n    let pathToShow;\n\n    startingPath.traverse({\n      enter(path) {\n        if (!pathToShow && isValid(path)) {\n          pathToShow = path;\n          path.stop();\n        }\n      }\n    });\n\n    return pathToShow;\n  }\n\n  /**\n   * Return the last valid path that is generated by a given callback function on the previous path\n   */\n  getLastPath(startingPath, nextPathCallback) {\n    let pathToShow = startingPath;\n    while (true) {\n      let nextPath = nextPathCallback(pathToShow);\n      if (nextPath) {\n        pathToShow = nextPath;\n      } else {\n        break;\n      }\n    }\n\n    return pathToShow;\n  }\n\n  /**\n   * Returns the first child of a node or the node itself, if it has no children\n   */\n  getFirstChildOrSelf(startingPath) {\n    let child;\n    startingPath.traverse({\n      enter(path) {\n        if (!child) {\n          child = path;\n        }\n      }\n    });\n    return child || startingPath;\n  }\n\n  /**\n  * Returns the nearest path before the cursor location\n  */\n  getPathBeforeCursor(startingPath, anchor) {\n    const selectionStart = loc(anchor);\n    let foundPath;\n    startingPath.traverse({\n      exit(path) {\n        const pathLocation = path.node.loc;\n        const pathEnd = loc(pathLocation.end);\n        if (selectionStart.isBefore(pathEnd)) {\n          path.stop();\n          return;\n        }\n        foundPath = path;\n      }\n    });\n    return foundPath;\n  }\n\n  /**\n   * Returns the innermost node, that contains the selected text.\n   */\n  getInnermostPathContainingSelection(startingPath, selection) {\n    // go down to minimal selected node\n    const nextPathContainingCursor = (newStartingPath, selection) => {\n      return this.nextPath(newStartingPath, path => {\n        return range(path.node.loc).containsRange(selection);\n      });\n    };\n    return this.getLastPath(startingPath, prevPath => nextPathContainingCursor(prevPath, selection));\n  }\n\n  getSelectedPaths(programPath) {\n    return this.selectionRanges.map(selection => {\n      const pathContainingWholeSelection = this.getInnermostPathContainingSelection(programPath, selection);\n\n      //path already matches the selection\n      if (this.isPathExactlySelected(pathContainingWholeSelection, selection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        enter(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedStatements(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isStatement(pathContainingWholeSelection) && !t.isBlockStatement(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Statement(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedExpressions(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isExpression(pathContainingWholeSelection) && !t.isIdentifier(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Expression(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc)) && !t.isIdentifier(path)) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  /** \n   * Takes the outermost node whose corresponding selection range is minimal for containing the selected text.\n   * a      foo = bar\n   * --b    foo\n   *   --c  foo\n   * \n   * In this example, when 'foo' is selected, b will be returned, since it is the outermost node that contains the\n   * entire selection, but nothing more.\n   */\n  getOutermostPathContainingSelectionWithMinimalSelectionRange(startingPath, selection) {\n    var currentPath = this.getInnermostPathContainingSelection(startingPath, selection);\n    currentPath.findParent(path => {\n      if (selection.isEqual(range(path.node.loc))) {\n        currentPath = path;\n      }\n      return false;\n    });\n    return currentPath;\n  }\n\n  /**\n   * Array of all children in depth first search order\n   */\n  forwardList(parentPath) {\n    const linearizedPathList = [];\n    parentPath.traverse({\n      exit(path) {\n        linearizedPathList.push(path);\n      }\n    });\n    return linearizedPathList;\n  }\n  /**\n   * Array of all children in reversed depth first search order\n   */\n  backwardList(parentPath) {\n    const linearizedPathList = [];\n    parentPath.traverse({\n      enter(path) {\n        linearizedPathList.push(path);\n      }\n    });\n    return linearizedPathList.reverse();\n  }\n  /**\n   * select the selection range of the next ast node after the current selection that satisfies a given condition\n   * select previous selection instead of next, if reversed is set to true\n   */\n  selectNextASTNodeWith(condition, reversed) {\n    const programPath = this.programPath;\n    const pathList = reversed ? this.backwardList(programPath) : this.forwardList(programPath);\n\n    const maxPaths = this.selectionRanges.map(selection => {\n\n      const currentPath = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      // do we fully select the current path?\n      if (selection.isEqual(range(currentPath.node.loc))) {\n        return this.getNextASTNodeInListWith(condition, pathList, currentPath);\n      } else {\n        return currentPath;\n      }\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  getFirstSelectedIdentifier(startPath) {\n    if (t.isIdentifier(startPath.node)) {\n      return startPath;\n    }\n    var first;\n    startPath.traverse({\n      Identifier(path) {\n        if (!first) {\n          first = path;\n          path.stop();\n        }\n      }\n    });\n    return first;\n  }\n\n  getFirstSelectedIdentifierWithName(startPath, name) {\n    if (t.isIdentifier(startPath.node, { name: name })) {\n      return startPath;\n    }\n    var first;\n    startPath.traverse({\n      Identifier(path) {\n        if (!first && t.isIdentifier(path.node, { name: name })) {\n          first = path;\n          path.stop();\n        }\n      }\n    });\n    return first;\n  }\n\n  getAllIdentifiers(startPath) {\n    var identifiers = [];\n    /*if (startPath.node.type == \"Identifier\") {\n      identifiers.push(startPath);\n    }*/\n    startPath.traverse({\n      Identifier(path) {\n        identifiers.push(path);\n      }\n    });\n    return identifiers;\n  }\n\n  getDeclaration(identifier) {\n    if (identifier.scope.hasBinding(identifier.node.name)) {\n      return identifier.scope.getBinding(identifier.node.name).path;\n    }\n  }\n\n  getBindingDeclarationIdentifierPath(binding) {\n    return this.getFirstSelectedIdentifierWithName(binding.path, binding.identifier.name);\n  }\n\n  getBindingsInFile(startPath) {\n    var identifier = this.getFirstSelectedIdentifier(startPath);\n    if (!identifier) return [];\n    const astBindings = this.getASTBinding(identifier)\n\n    if(astBindings) {\n      return astBindings;\n    }\n\n    return this.getClassBindings(identifier);\n  }\n\n  getASTBinding(identifier) {\n    if (identifier.scope.hasBinding(identifier.node.name)) {\n      const binding = identifier.scope.getBinding(identifier.node.name);\n      const identifierPaths = [...new Set([this.getBindingDeclarationIdentifierPath(binding), ...binding.referencePaths, ...binding.constantViolations.map(cv => this.getFirstSelectedIdentifierWithName(cv, binding.identifier.name))])];\n      if (identifierPaths.includes(identifier)) {\n        return identifierPaths;\n      }\n    }\n    return undefined;\n  }\n\n  getClassBindings(identifier) {\n    if (t.isMemberExpression(identifier.parent)) {\n      if (t.isThisExpression(identifier.parent.object)) {\n        let classPath = this.getClassPath(this.programPath);\n        let methodPath = this.getMethodPath(classPath, identifier.node.name);\n        if (methodPath) {\n          return this.getClassMethodBindings(methodPath);\n        } else {\n          return this.getMemberBindings(identifier);\n        }\n      }\n    } else if (t.isClassMethod(identifier.parent)) {\n      return this.getClassMethodBindings(identifier.parentPath);\n    }\n  }\n\n  getClassMethodBindings(classMethod) {\n    var methodIdentifier;\n    classMethod.traverse({\n      Identifier(path) {\n        path.stop();\n        methodIdentifier = path;\n      }\n    });\n    return [methodIdentifier, ...this.getMemberBindings(methodIdentifier)];\n  }\n\n  /**\n   * if getUnbound is set to true, instead of getting all member Expressions with this (= that are bound) we only get those, that are unbound\n   */\n  getMemberBindings(identifier, getUnbound = false, startPath = this.programPath) {\n    var members = [];\n    startPath.traverse({\n      Identifier(path) {\n        if (t.isMemberExpression(path.parent) && path.node.name === identifier.node.name) {\n          if (t.isThisExpression(path.parent.object) && !getUnbound) {\n            members.push(path);\n          } else if (getUnbound) {\n            members.push(path);\n          }\n        }\n      }\n    });\n    return members;\n  }\n\n  getAllUnboundIdentifierNames(startPath = this.programPath) {\n    var unboundIdentifiers = [];\n    startPath.traverse({\n      Identifier(path) {\n        if (t.isMemberExpression(path.parent)) {\n          if (!t.isThisExpression(path.parent.object)) {\n            unboundIdentifiers.push(path);\n          }\n        }\n      }\n    });\n    return unboundIdentifiers.map(binding => binding.node.name).filter((value, index, self) => self.indexOf(value) === index);\n  }\n\n  getNextASTNodeInListWith(condition, pathList, path) {\n    const currentPathInList = pathList.find(pathInList => pathInList.node === path.node);\n    const currentIndex = pathList.indexOf(currentPathInList);\n    for (var i = currentIndex + 1; i < pathList.length; i++) {\n      if (condition(path, pathList[i])) {\n        return pathList[i];\n      }\n    }\n    return pathList[pathList.length - 1];\n  }\n\n  /** \n   * Select the text corresponding to the given nodes\n   */\n  selectNodes(nodes, selectStringContentsOnly = false) {\n    const ranges = nodes.map(node => range(node.loc));\n    this.codeProvider.selections = ranges;\n  }\n\n  /** \n   * Select the text corresponding to the given paths\n   */\n  selectPaths(paths, selectStringContentsOnly = false) {\n    this.selectNodes(paths.map(path => path.node), selectStringContentsOnly);\n  }\n\n  /** \n   * Get the path for the first method with the given name\n   */\n  getMethodPath(programPath, name) {\n    let methodPath;\n    programPath.traverse({\n      ClassMethod(path) {\n        if (!methodPath && path.node.key.name == name) {\n          methodPath = path;\n        }\n      },\n      FunctionDeclaration(path) {\n        if (!methodPath && path.node.id.name == name) {\n          methodPath = path;\n        }\n      }\n    });\n    return methodPath;\n  }\n\n  /** \n   * Get the path of the first file\n   */\n  getClassPath(programPath) {\n    let classPath;\n    programPath.traverse({\n      ClassDeclaration(path) {\n        if (!classPath) {\n          classPath = path;\n        }\n      }\n    });\n    return classPath;\n  }\n\n  getColorLiterals() {\n    var pPath = this.programPath;\n    if(!pPath) return;\n    let colorPaths = [];\n    const colorRegex = /(0[xX]|#)[0-9a-fA-F]{6}$/g;\n    pPath.traverse({\n      StringLiteral(path) {\n        if (path.node.value.match(colorRegex)) {\n          colorPaths.push(path);\n        }\n      }\n    });\n    return colorPaths;\n  }\n\n  /*MD ### Shortcuts MD*/\n\n  expandSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      // go up again\n      return pathToShow.find(path => {\n        return range(path.node.loc).strictlyContainsRange(selection);\n      }) || pathToShow;\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  reduceSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      return this.getFirstChildOrSelf(pathToShow);\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  selectNextASTChild(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => {\n      return t.isIdentifier(nextNode) || t.isLiteral(nextNode) || t.isThisExpression(nextNode) || t.isSuper(nextNode) || t.isDebuggerStatement(nextNode);\n    }, reversed);\n  }\n\n  selectNextASTNodeLikeThis(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => currentNode.type == nextNode.type, reversed);\n  }\n\n  selectNextReference(reversed) {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);if (bindings) {\n      let sortedBindings = [...bindings].sort((a, b) => a.node.start - b.node.start);\n      let index = sortedBindings.indexOf(selectedPath);\n      index += reversed ? -1 : 1;\n      index = (index + sortedBindings.length) % sortedBindings.length;\n      this.selectPaths([sortedBindings[index]]);\n    }\n  }\n\n  async selectDeclaration() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) {\n      return;\n    }\n    const identName = identifier.node.name;\n\n    const declaration = await this.getDeclaration(identifier);\n    //needs smarter selection of source\n    if (declaration && !t.isImportSpecifier(declaration)) {\n      this.selectPaths([declaration]);\n    } else {\n      let classPath = this.getClassPath(this.programPath);\n      let methodPath = this.getMethodPath(classPath, identName);\n      if (methodPath) {\n        this.selectNodes([methodPath.node.key]);\n      } else {\n        const classUrls = await this.getCorrespondingClasses(identName).then(arr => arr.map(cl => cl.url));\n        const functionUrls = await this.getFunctionExportURLs(identName);\n        const urls = classUrls.concat(functionUrls);\n\n        urls.forEach(url => lively.openBrowser(url, true).then(container => {\n          container.asyncGet(\"#editor\").then(async livelyEditor => {\n            let newCodeMirror = livelyEditor.livelyCodeMirror();\n            var cm = await livelyEditor.awaitEditor();\n            newCodeMirror.astCapabilities(cm).then(ac => {\n              ac.selectPaths([ac.getMethodPath(ac.programPath, identName)]);\n            });\n          });\n        }));\n      }\n    }\n    /**\n      TODO: if our dependencies don't have the method, we can search all classes    \n      Also: do not only search for methods, but for members too (even though they are technically not bindings?)\n    */\n  }\n\n  async rename() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    var identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) return;\n    const astBindings = this.getASTBinding(identifier)\n\n    if(astBindings) {\n      this.selectPaths(astBindings);\n      return;\n    }\n    \n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\n\n    \n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setAdditionalInput(\"Name\", \"enter new name\");\n    comp.setTitle(\"Rename \" + identifier.node.name);\n    const references = await comp.selectItems(bindingItems);\n    \n    const newName = comp.getAdditionalInput().camelCase();\n    if(newName === \"\") return;\n    \n    for(const reference of references) {\n      const code = await fetch(reference.url).then(r => r.text());\n      \n      const codeLines = code.split(\"\\n\");\n      \n      String.prototype.replaceBetween = function(start, end, what) {\n        return this.substring(0, start) + what + this.substring(end);\n      };\n      codeLines[reference.line] = codeLines[reference.line].replaceBetween(reference.ch, reference.ch + identifier.node.name.length, newName);\n      \n      const newCode = codeLines.join(\"\\n\");\n      await lively.files.saveFile(reference.url, newCode);\n      await lively.reloadModule(reference.url)\n      await System.import(reference.url);\n    }\n  }\n\n  selectBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);\n    if (bindings) {\n      this.selectPaths(bindings);\n    }\n  }\n\n  async printAllBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    //const bindings = this.getBindings(selectedPath);\n    var identifier = this.getFirstSelectedIdentifier(selectedPath);\n\n    //find classes that contain the method\n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\n\n    this.openReferencesMenu(bindingItems, identifier.node.name);\n  }\n\n  async getPossibleBindingsAcrossFiles(identifier) {\n    let index = await FileIndex.current();\n    let ids = await index.db.files.filter(file => {\n      if (!file.unboundIdentifiers) return false;\n      return file.unboundIdentifiers.some(id => id.name == identifier.name);\n    }).toArray();\n    const bindingItems = [];\n\n    for (const id of ids) {\n      const code = await fetch(id.url).then(r => r.text());\n      const program = this.programPathFor(code);\n      for (const reference of this.getMemberBindings(identifier, true, program)) {\n        const line = reference.node.loc.start.line - 1;\n        const ch = reference.node.loc.start.column;\n        bindingItems.push({ id: id.url.substring(id.url.lastIndexOf(\"/\") + 1) + \": \" + line, url: id.url, line, ch });\n      }\n    }\n\n    return bindingItems;\n  }\n\n  async openReferencesMenu(ids, identifierName) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"References of \" + identifierName);\n    return comp.selectItems(ids);\n  }\n\n  async findImports() {\n    let functions, classes, identName;\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (identifier) {\n      identName = identifier.node.name;\n      functions = await this.getFunctionExportURLs(identName);\n      classes = await this.getCorrespondingClasses(identName);\n    }\n    return { identName, functions, classes };\n  }\n  /*MD ## Factoring Menu MD*/\n\n  /*MD ### Factoring Menu Helper Methods MD*/\n\n  // returns innermostDescribePath \n  isInDescribe(path) {\n    let possiblePath = this.isIn(\"CallExpression\", path, \"describe\");\n\n    while (possiblePath !== null) {\n      if (possiblePath.node && possiblePath.node.callee.name === \"describe\") {\n        break;\n      }\n      possiblePath = this.isIn(\"CallExpression\", possiblePath.parentPath, \"describe\");\n    }\n    return possiblePath;\n  }\n\n  isIn(type, path) {\n    while (path !== null) {\n      if (this.isDirectlyIn(type, path)) {\n        return path;\n      }\n      path = path.parentPath;\n    }\n    return null;\n  }\n\n  isDirectlyIn(type, path) {\n    if (type instanceof Array) {\n      return type.map(elem => this.isDirectlyIn(elem, path)).reduce((accu, elem) => accu || elem, false);\n    }\n    return path.node && path.node.type === type;\n  }\n\n /*MD ## Color Picker MD*/\n\n\n  updateColor(currentLocation, color) {\n    var location = { anchor: currentLocation, head: currentLocation };\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.getInnermostPathContainingSelection(programPath, range(location)); //this.getPathBeforeCursor(programPath, currentLocation);\n          if (t.isStringLiteral(path.node)) {\n            path.node.value = color;\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n  }\n  /*MD ## Generations MD*/\n\n  /*MD ### Generate Testcase / Class / get / set / HTML accessorss MD*/\n\n  async openHTMLAccessorsMenu(ids, initialSelectionState) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"HTML Accessor Menu\");\n    return comp.selectItems(ids, initialSelectionState);\n  }\n\n  getExistingAccessors() {\n    let classMethodIdentifier;\n    this.programPath.traverse({\n      ExportDefaultDeclaration(path) {\n        if (path && path.node.declaration && path.node.declaration.type == \"ClassDeclaration\") {\n          classMethodIdentifier = path.node.declaration.body.body.map(elem => elem.key.name);\n          path.stop();\n        }\n      }\n    });\n    return classMethodIdentifier || [];\n  }\n\n  async generateHTMLAccessors() {\n    const ids = await this.compileListOfIDs();\n    if (ids.length == 0) {\n      return;\n    }\n\n    let existingMethods = this.getExistingAccessors();\n    let initialSelectionState = ids.map(elem => existingMethods.includes(this.generateMethodNameFromProperty(elem.id)));\n    const selectedItems = await this.openHTMLAccessorsMenu(ids, initialSelectionState);\n\n    if (selectedItems.length === 0) {\n      return;\n    }\n    lively.warn(`${selectedItems.length} Accessors generated`);\n\n    selectedItems.forEach(item => {\n      this.generateCodeFragment(item.id, name => this.compileHTMLGetter(name));\n      const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n      let line = selectedPath.parent.loc.end.line + 1;\n      this.codeProvider.cursor = loc({line, ch: 0});\n    });\n  }\n\n  async compileListOfIDs() {\n    const htmlURI = this.codeProvider.htmlURI;\n    let html = await htmlURI.fetchText();\n\n    if (html === \"File not found!\\n\") {\n      lively.warn(\"There is no HTML associated with this file.\");\n      return [];\n    }\n\n    let tmp = <div></div>;\n    tmp.innerHTML = html;\n    let ids = tmp.childNodes[0].content.querySelectorAll(\"[id]\").map(ea => ea.id);\n\n    const htmlLines = html.split(\"\\n\");\n\n    const idsWithLocation = [];\n    for (const id of ids) {\n      for (const line of htmlLines) {\n        const indexOfId = line.indexOf(\"id=\\\"\" + id + \"\\\"\");\n        if (indexOfId !== -1) {\n          idsWithLocation.push({ id, url: htmlURI, line: htmlLines.indexOf(line), ch: indexOfId + 4 });\n          break;\n        }\n      }\n    }\n    return idsWithLocation;\n  }\n\n  generateTestCase() {\n    this.generateCodeFragment(\"ExplainWhatIsTested\", id => this.compileTestCase(id.identifier));\n  }\n\n  generateGetter() {\n    this.generateCodeFragment(\"NameThisGetter\", id => this.compileGetter(id.identifier));\n  }\n\n  generateSetter() {\n    this.generateCodeFragment(\"NameThisSetter\", id => this.compileSetter(id.identifier));\n  }\n\n  generateClass() {\n    this.generateCodeFragment(\"SetClassName\", id => this.compileClass(id.identifier));\n  }\n\n  async generateCodeFragment(identifier, replacementGenerator) {\n    const scrollInfo = this.scrollInfo;\n    const selection = this.firstSelection;\n\n    var identifierObject = { identifier };\n\n    var generatedCode;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let pathBefore = this.getPathBeforeCursor(programPath, selection.start);\n          let pathWithin = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n          // we're on top of the program\n          generatedCode = replacementGenerator(identifierObject);\n          if (pathBefore === undefined) {\n            pathWithin.unshiftContainer('body', generatedCode);\n          } else if (this.isDirectlyIn(pathWithin.type, pathBefore.parentPath)) {\n            pathBefore.insertAfter(generatedCode);\n          } else {\n            pathWithin.unshiftContainer('body', generatedCode);\n          }\n        }\n      }\n    })).code;\n\n    var pathToSelect;\n    this.programPath.traverse({\n      StringLiteral(path) {\n        if (!pathToSelect && path.node.value == identifierObject.identifier) {\n          pathToSelect = path;\n        }\n      },\n      Identifier(path) {\n        if (path.node.name == identifierObject.identifier) {\n          pathToSelect = path;\n          path.stop();\n        }\n      }\n    });\n    this.selectPaths([pathToSelect], true);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  compileTestCase(explanation) {\n    return template(\"it(EXP, () => {\\n\" + \"let put = 'code here';\" + \"})\")({\n      EXP: t.stringLiteral(explanation)\n    });\n  }\n\n  //TODO: nice identifier\n  compileGetter(propertyName) {\n    return t.classMethod(\"get\", t.identifier(propertyName), [], t.blockStatement([t.returnStatement(t.memberExpression(t.thisExpression(), t.identifier(\"internalPropertyName\")))]));\n  }\n\n  compileSetter(propertyName) {\n    return t.classMethod(\"set\", t.identifier(propertyName), [t.Identifier(\"newValue\")], t.blockStatement([t.expressionStatement(t.assignmentExpression(\"=\", t.memberExpression(t.thisExpression(), t.identifier(\"internalPropertyName\")), t.identifier(\"newValue\")))]));\n  }\n\n  compileClass(className) {\n    return t.classDeclaration(t.identifier(className), null, t.classBody([t.classMethod(\"constructor\", t.Identifier(\"constructor\"), [], t.blockStatement([]))]), []);\n  }\n\n  compileHTMLGetter(property) {\n    var propertyName = property.identifier;\n    var methodName = this.generateMethodNameFromProperty(propertyName);\n    property.identifier = methodName;\n    return t.classMethod(\"get\", t.identifier(methodName), [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(\"get\")), [t.stringLiteral(\"#\" + propertyName)]))]));\n  }\n\n  generateMethodNameFromProperty(name) {\n    return name.camelCase();\n  }\n\n  async getUserInput(description, defaultValue) {\n    let input = await lively.prompt(description, defaultValue);\n    return new Promise((resolve, reject) => {\n      if (input) {\n        resolve(input);\n      } else {\n        reject(\"No input given!\");\n      }\n    });\n  }\n\n  /*MD ### Generate Import MD*/\n\n  addImport(url, importName, isFunction) {\n    const selection = this.firstSelection;\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let existingImportStatement = this.nextPath(programPath, path => {\n            return t.isImportDeclaration(path) && path.node.source.value == url;\n          });\n          let selectedPath = this.getInnermostPathContainingSelection(programPath, selection);\n          if (!existingImportStatement) {\n            let importStatement = t.importDeclaration([t.importSpecifier(t.identifier(importName), t.identifier(importName))], t.stringLiteral(url));\n            programPath.node.body.unshift(importStatement);\n          } else if (!existingImportStatement.node.specifiers.some(spec => spec.imported.name == importName)) {\n            existingImportStatement.node.specifiers.push(t.identifier(importName));\n          }\n          if (!isFunction) {\n            selectedPath.replaceWith(t.memberExpression(t.identifier(importName), t.identifier(selectedPath.node.name)));\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Transformations MD*/\n\n  /*MD ### Extract Method MD*/\n  findParameters(identifiers, surroundingMethod, actualSelections) {\n    return identifiers.filter(identifier => {\n      return this.needsToBeParameter(identifier, surroundingMethod);\n    }).filter(identifier => {\n      const bindingPath = identifier.scope.getBinding(identifier.node.name).path;\n      return !this.isSelected(bindingPath, actualSelections);\n    }).map(identifier => {\n      return this.getBindingDeclarationIdentifierPath(identifier.scope.getBinding(identifier.node.name)).node;\n    });\n  }\n\n  shouldBeAsync(content) {\n    let hasAwait = false;\n    content.forEach(startPath => {\n      if (t.isAwaitExpression(startPath.node)) {\n        hasAwait = true;\n      } else {\n        startPath.traverse({\n          AwaitExpression(path) {\n            hasAwait = true;\n            path.stop();\n          }\n        });\n      }\n    });\n\n    return hasAwait;\n  }\n\n  couldBeStatic(content) {\n    let hasThis = false;\n    content.forEach(startPath => {\n      startPath.traverse({\n        ThisExpression(path) {\n          hasThis = true;\n          path.stop();\n        }\n      });\n    });\n\n    return !hasThis;\n  }\n\n  needsToBeParameter(identifier, surroundingMethod) {\n    return identifier.scope.hasBinding(identifier.node.name) && !surroundingMethod.parentPath.scope.hasBinding(identifier.node.name);\n  }\n\n  findReturnValues(identifiers, surroundingMethod, actualSelections) {\n    const bindings = [...new Set(identifiers.filter(identifier => {\n      return identifier.scope.hasBinding(identifier.node.name) && !surroundingMethod.parentPath.scope.hasBinding(identifier.node.name);\n    }).map(identifier => {\n      return identifier.scope.getBinding(identifier.node.name);\n    }))];\n\n    return bindings.filter(binding => {\n      const declarationInSelection = this.isSelected(binding.path, actualSelections);\n      const constantViolationInSelection = binding.constantViolations.some(constantViolation => this.isSelected(constantViolation, actualSelections));\n      const referenceOutsideSelection = binding.referencePaths.some(reference => !this.isSelected(reference, actualSelections));\n\n      return this.needsToBeReturned(declarationInSelection, constantViolationInSelection, referenceOutsideSelection);\n    }).map(binding => {\n      const constantViolationOutsideSelection = binding.constantViolations.some(constantViolation => !this.isSelected(constantViolation, actualSelections));\n      return { node: this.getBindingDeclarationIdentifierPath(binding).node, declaredInExtractedCode: this.isSelected(binding.path, actualSelections), constantViolationOutsideSelection };\n    });\n  }\n\n  needsToBeReturned(declarationInSelection, constantViolationInSelection, referenceOutsideSelection) {\n    return !declarationInSelection && constantViolationInSelection || (constantViolationInSelection || declarationInSelection) && referenceOutsideSelection;\n  }\n\n  createMethod(content, parameter, returnValues, scope, extractingExpression, shouldBeAsync, shouldBeStatic) {\n    if (extractingExpression && returnValues.length > 0) {\n      lively.warn(\"Unable to extract an expression, that assigns something to variables used outside the expression.\");\n    }\n    var returnStatement;\n    returnValues.forEach(returnValue => returnValue.returnIdentifier = returnValue.declaredInExtractedCode ? returnValue.node : t.identifier(returnValue.node.name + \"_return\"));\n    if (returnValues.length == 1) {\n      returnStatement = t.returnStatement(returnValues[0].node);\n    } else if (returnValues.length > 1) {\n      returnStatement = t.returnStatement(t.objectExpression(returnValues.map(i => t.objectProperty(i.returnIdentifier, i.node, false, true))));\n    }\n\n    var methodContent = content.map(p => {\n      //remove formatting for propper re-formatting\n      p.node.loc = null;\n      p.node.start = null;\n      p.node.end = null;\n      return p.node;\n    });\n    if (returnStatement) {\n      methodContent.push(returnStatement);\n    } else if (extractingExpression) {\n      methodContent = [t.returnStatement(content[0].node)];\n    }\n    const newMethod = t.classMethod(\"method\", t.identifier(\"HopefullyNobodyEverUsesThisMethodName\"), parameter, t.blockStatement(methodContent));\n    newMethod.async = shouldBeAsync;\n    newMethod.static = shouldBeStatic;\n    scope.insertAfter(newMethod);\n    for (let i = 0; i < content.length - 1; i++) {\n      content[i].remove();\n    }\n    var methodCall;\n    var callExpression = t.callExpression(t.identifier(\"this.HopefullyNobodyEverUsesThisMethodName\"), parameter);\n    if (shouldBeAsync) {\n      lively.warn(\"Extracting async method. This could change the control flow.\");\n      callExpression = t.awaitExpression(callExpression);\n    }\n    if (returnValues.length == 1) {\n      if (returnValues[0].declaredInExtractedCode) {\n        const variableType = returnValues[0].constantViolationOutsideSelection ? \"var\" : \"const\";\n        methodCall = [t.variableDeclaration(variableType, [t.variableDeclarator(returnValues[0].node, callExpression)])];\n      } else {\n        methodCall = [t.expressionStatement(t.assignmentExpression(\"=\", returnValues[0].node, callExpression))];\n      }\n    } else if (returnValues.length > 1) {\n      const objectPattern = t.objectPattern(returnValues.map(i => t.objectProperty(i.returnIdentifier, i.returnIdentifier, false, true)));\n      methodCall = [t.variableDeclaration(\"const\", [t.variableDeclarator(objectPattern, callExpression)])];\n      returnValues.forEach(returnStatement => {\n        if (returnStatement.node != returnStatement.returnIdentifier) {\n          methodCall.push(t.expressionStatement(t.assignmentExpression(\"=\", returnStatement.node, returnStatement.returnIdentifier)));\n        }\n      });\n    } else {\n      methodCall = [callExpression];\n    }\n    content[content.length - 1].replaceWithMultiple(methodCall);\n  }\n\n  async extractMethod() {\n    const scrollInfo = this.scrollInfo;\n    const transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const {\n            selectedPaths,\n            extractingExpression,\n            actualSelections\n          } = this.selectMethodExtraction(programPath);\n\n          const identifiers = selectedPaths.map(this.getAllIdentifiers).flat();\n          let surroundingMethod = selectedPaths[0].find(parent => {\n            return parent.node.type == \"ClassMethod\";\n          });\n          var shouldBeStatic = this.couldBeStatic(selectedPaths);\n          if (!surroundingMethod) {\n            surroundingMethod = selectedPaths[selectedPaths.length - 1];\n          } else {\n            shouldBeStatic = surroundingMethod.node.static;\n          }\n          const shouldBeAsync = this.shouldBeAsync(selectedPaths);\n          const parameters = this.findParameters(identifiers, surroundingMethod, actualSelections);\n          const returnValues = this.findReturnValues(identifiers, surroundingMethod, actualSelections);\n          this.createMethod(selectedPaths, [...new Set(parameters)], returnValues, surroundingMethod, extractingExpression, shouldBeAsync, shouldBeStatic);\n        }\n      }\n    }));\n    this.sourceCode = transformed.code;\n    this.scrollTo(scrollInfo);\n    const pathsToSelect = [];\n    this.programPath.traverse({\n      Identifier(path) {\n        if (path.node.name == \"HopefullyNobodyEverUsesThisMethodName\") {\n          pathsToSelect.push(path);\n        }\n      }\n    });\n    this.selectPaths(pathsToSelect);\n  }\n\n  /*MD ### Extract Variable MD*/\n\n  selectMethodExtraction(programPath, silent = false) {\n    var selectedPaths = this.getSelectedStatements(programPath);\n    var extractingExpression = false;\n\n    if (selectedPaths.length == 0) {\n      var expressions = this.getSelectedExpressions(programPath);\n      if (expressions.length > 1) {\n        if (!silent) lively.warn('You cannot extract multiple statements at once. Select statements or a single expression!');\n        return;\n      } else if (expressions.length == 0) {\n        if (!silent) lively.warn('Select statements or an expression to extract!');\n        return;\n      } else {\n        selectedPaths = expressions;\n        extractingExpression = true;\n      }\n    }\n\n    const actualSelections = selectedPaths.map(path => {\n      return range(path.node.loc);\n    });\n    return {\n      selectedPaths,\n      extractingExpression,\n      actualSelections\n    };\n  }\n\n  async extractExpressionIntoLocalVariable() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(({ types: t }) => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n\n              path.find(p => {\n                const parentPath = p.parentPath;\n                if (!parentPath) {\n                  return false;\n                }\n\n                function ensureBlock(body) {\n                  if (!body.node) return false;\n\n                  if (body.isBlockStatement()) {\n                    return false;\n                  }\n\n                  const statements = [];\n                  if (body.isStatement()) {\n                    statements.push(body.node);\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else if (body.parentPath.isArrowFunctionExpression() && body.isExpression()) {\n                    statements.push(t.returnStatement(body.node));\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else {\n                    throw new Error(\"I never thought this was even possible.\");\n                  }\n                }\n\n                const targetLocation = path.getPathLocation();\n                const blockLocation = p.getPathLocation();\n                if (p.parentKey === 'body' && (parentPath.isFor() || parentPath.isWhile())) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if (p.parentKey === 'body' && parentPath.isFunction()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0].argument' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if ((p.parentKey === 'consequent' || p.parentKey === 'alternate') && parentPath.isIfStatement()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n              });\n\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No Expression to extract found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          let value = '';\n          path.traverse({\n            Identifier(p) {\n              value += '-' + p.node.name;\n            }\n          });\n          if (value.length > 0) {\n            // #TODO: ensure unique identifier\n            value = value.camelCase();\n          } else {\n            value = path.scope.generateUidIdentifier('temp').name;\n          }\n          const identifier = t.Identifier(value);\n          const decl = template('const ID = INIT;')({\n            ID: identifier,\n            INIT: path.node\n          });\n\n          let referree = t.Identifier(value);\n\n          path.replaceWith(referree);\n          const insertedDeclaration = path.getStatementParent().insertBefore(decl)[0];\n          const insertedDeclarationIdentifier = insertedDeclaration.get('declarations')[0].get('id');\n\n          pathLocationsToSelect.push(insertedDeclarationIdentifier.getPathLocation());\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.scrollTo(scrollInfo);\n  }\n\n  async wrapExpressionIntoActiveExpression() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No `Expression` to wrap found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          const ae = template('aexpr(() => EXPR)')({\n            EXPR: path.node\n          }).expression;\n\n          path.replaceWith(ae);\n\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Accessors MD*/\n\n  get sourceCode() {\n    return this.codeProvider.code;\n  }\n  set sourceCode(text) {\n    this.codeProvider.code = text;\n    this.codeChanged();\n    return this.codeProvider.code;\n  }\n  \n  get scrollInfo() {\n    return this.codeProvider.scrollInfo;\n  }\n  \n  scrollTo(scrollInfo) {\n    this.codeProvider.scrollInfo;\n  }\n\n  /*MD ## Utilities MD*/\n\n  isSelected(path, selections = null) {\n    if (!selections) {\n      selections = this.selectionRanges;\n    }\n    const pathRange = range(path.node.loc);\n    for (const selection of selections) {\n      if (selection.containsRange(pathRange)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  isPathExactlySelected(path, selection) {\n    return selection.isEqual(range(path.node.loc));\n  }\n\n  pathByLocationFromProgram(programPath, location) {\n    let path = programPath;\n    const reg = /(\\.[A-Za-z0-9]+|(\\[[0-9]+\\]))/ig;\n    let result;\n    while ((result = reg.exec(location)) !== null) {\n      let part = result[0];\n      if (part.startsWith('.')) {\n        part = part.replace('.', '');\n        path = path.get(part);\n      } else {\n        part = part.replace(/\\[|\\]/ig, '');\n        part = parseInt(part);\n        path = path[part];\n      }\n    }\n\n    return path;\n  }\n\n  pathLocationsToPathes(pathLocations) {\n    const paths = [];\n\n    this.sourceCode.traverseAsAST({\n      Program: path => {\n        pathLocations.forEach(location => {\n          paths.push(this.pathByLocationFromProgram(path, location));\n        });\n      }\n    });\n\n    return paths;\n  }\n\n  async getCorrespondingClasses(methodName) {\n    let index = await FileIndex.current();\n\n    //find classes that contain the method\n    let possibleClasses = await index.db.classes.filter(cl => {\n      return cl.methods.some(me => me.name == methodName);\n    }).toArray();\n\n    //find files that export things with the urls from the found classes\n    let possibleExports = await index.db.exports.where('url').anyOf(possibleClasses.map(cl => cl.url)).toArray();\n\n    //reduce the found classes with the found possible exports\n    let locations = possibleClasses.filter(cl => {\n      return possibleExports.some(e => e.url == cl.url && e.classes.some(eCl => eCl == cl.name));\n    });\n    return locations.filter(ea => ea.url.match(lively4url)); //filter local files\n  }\n\n  async getFunctionExportURLs(methodName) {\n    let index = await FileIndex.current();\n    let locations = await index.db.exports.filter(exp => {\n      return exp.functions.some(me => me == methodName);\n    }).toArray();\n    return locations.map(loc => loc.url).filter(url => url.match(lively4url));\n  }\n\n\n  \n  /*MD ## Active_Expressions MD*/\n\n  getAexprAtCursor(location) {\n    let aexprPath;\n\t\tthis.programPath.traverse({\n\t\t\tCallExpression(path) {\n        if (!range(path.node.loc).contains(location)) {\n          path.skip();\n        } else if (isAExpr(path)) {\n          aexprPath = path;\n          path.stop();\n\t\t\t\t}\n\t\t\t}\n    });\n    return aexprPath;\n  }\n\n  get hasActiveExpressionsDirective() {\n    return this.programPath.node.directives.some(node => {\n      return node.value.value === \"enable aexpr\";\n    });\n  }\n\n  ensureEnrichment() {\n    if (this.finishedEnrichment) return true;\n    if (!this.programPath || !this.hasActiveExpressionsDirective) return false;\n    try {\n      this.enrich();\n    } catch (err) {\n      console.error(\"Unable to process source code\", err);\n      return false;\n    }\n    return true;\n  }\n  \n  enrich() {\n    let self = this;\n\t\tthis.rootNode.traverseAsAST({\n\t\t\tenter(path) {\n\t\t\t\tpath.node.extra = {\n\t\t\t\t\t// this is necessary due to possible circles\n\t\t\t\t\t// this collects the correct dependencies\n\t\t\t\t\t// breaks (meaning not beeing entirely correct anymore) as soon as a node is contained by more than one circle (but this turned out to be unlikely)\n\t\t\t\t\tvisited: 2,\n\t\t\t\t\t//same for return recursion\n\t\t\t\t\treturnVisited: 2\n\t\t\t\t};\n\t\t\t}\n    });\n\n\t\t// adds the corresponding binding to every identifier\n\t\tthis.rootNode.traverseAsAST({\n      Scope(path) {\n\t\t\t\tObject.entries(path.scope.bindings).forEach(([_name, binding]) => {\n\t\t\t\t\tbinding.referencePaths.forEach(path => {\n\t\t\t\t\t\tpath.node.extra.binding = binding;\n\t\t\t\t\t})\n\t\t\t\t})\n\t\t\t}\n\t\t});\n\n\t\tthis.extractMemberAssignments();\n    \n    this.enrichFunctionNodes();\n\n\t\tthis.programPath.traverse({\n\t\t\tExpression(expr) {\n\t\t\t\tself.collectExpressionInformation(expr);\n\t\t\t}\n    });\n    \n    this.finishedEnrichment = true;\n\t}\n  \n  // Filters every member assignment and registers it in `this.memberAssignments`\n  extractMemberAssignments(){\n    let self = this;\n    this.programPath.traverse({\n\t\t\tMemberExpression(expr) {\n\t\t\t\tif (expr.node.computed) return;\n\t\t\t\tif (!expr.parentPath.isAssignmentExpression()) return;\n        let assignment = self.assignedValue(expr.parentPath);\n\n\t\t\t\tlet obj = expr.get(\"object\");\n\t\t\t\tlet objKey = obj.node.extra.binding || 'misc';\n\t\t\t\tlet property = expr.get(\"property\").node.name;\n\n\t\t\t\tlet entry = self.memberAssignments.get(property);\n\t\t\t\tif (!entry) {\n\t\t\t\t\t// property unknown, adding new property and its accesses to the map\n\t\t\t\t\tlet newMap = new Map();\n\n\t\t\t\t\tnewMap.set(objKey, [assignment]);\n\t\t\t\t\tself.memberAssignments.set(property, newMap);\n\t\t\t\t} else {\n\t\t\t\t\tlet objEntry = entry.get(objKey);\n\t\t\t\t\tif (!objEntry) {\n\t\t\t\t\t\tobjEntry = [];\n\t\t\t\t\t\tentry.set(objKey, objEntry);\n\t\t\t\t\t}\n\t\t\t\t\tobjEntry.push(assignment);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n  }\n  \n  enrichFunctionNodes(){\n  // adds bindings definend outside of the current scope(e.g. Function) to the scope\n    this.rootNode.traverseAsAST({\n      'Function|ArrowFunctionExpression|Program'(path) {\n        path.node.extra.leakingBindings = leakingBindings(path);\n        const callExpressions = path.node.extra.callExpressions = [];\n        const objects = path.node.extra.objects = new Map();\n        const returns = path.node.extra.returns = [];\n\n        path.traverse({\n          MemberExpression(expr) {\n            if (expr.parentPath.isAssignmentExpression()) return;\n            let objExpr = expr.get(\"object\").node;\n            let property = expr.get(\"property\").node.name;\n\n            let entry = objects.get(objExpr);\n            if (!entry) {\n              objects.set(objExpr, new Set([property]));\n            } else {\n              entry.add(property);\n            }\n          }\n        });\n\n        path.traverse({\n          ReturnStatement(ret) {\n            if (ret.has(\"argument\")) {\n              returns.push(ret.get(\"argument\"));\n            }\n          },\n          CallExpression(call) {\n            callExpressions.push(call)\n          }\n        })\n      }\n    });\n  }\n  \n  /* Main recursion for enriching AST \n  *  Resolves Expression nodes and follows their children in order to find\n  *  - resolvedObjects - the {ObjExpression, [Bindings]} in which the expression may result\n  *  - resolvedCallees - the [Function] which callepressions may actually be\n  *  - results         - the [Function] which may be returned by an expression or Identifier\n  *\n  */\n\tcollectExpressionInformation(path) {\n\t\tif (path.node.extra.returnVisited <= 0) {\n\t\t\treturn [];\n\t\t}\n\n\t\tpath.node.extra.returnVisited -= 1;\n\n\t\tif (path.node.extra.results) {\n\t\t\treturn path.node.extra.results\n\t\t}\n\n\t\tlet results = [];\n    let resolvedObjects = [];\n\n\t\tif (path.isObjectExpression()) {\n      resolvedObjects = [{objectExpression:path, bindings:new Set()}];\n\n\t\t} else if (path.isIdentifier()) {\n      if (!path.parentPath.isUpdateExpression()) {\n        let binding = path.node.extra.binding;\n        if (binding) {\n          [binding.path, ...binding.constantViolations].forEach(item => {\n            this.collectExpressionInformation(item);\n            results.push(item.node.extra.results);\n            item.node.extra.resolvedObjects.forEach(obj =>{\n              obj.bindings.add(binding);            \n              resolvedObjects.push(obj);            \n            })\n          })\n        }\n      }\n    } else if (path.isAssignmentExpression() || path.isVariableDeclarator()) {\n      let val = this.assignedValue(path);\n\t\t\tthis.collectExpressionInformation(val);\n\t\t\tresults = val.node.extra.results;\n      resolvedObjects = val.node.extra.resolvedObjects;\n    } else if (path.isFunction()) {\n\t\t\tresults = [path];\n\t\t} else if (path.isConditionalExpression()) {\n\t\t\t[path.get(\"consequent\"), path.get(\"alternate\")].forEach(expr => {\n\t\t\t\tthis.collectExpressionInformation(expr);\n\t\t\t\tresults.push(expr.node.extra.results);\n        resolvedObjects.push(expr.node.extra.resolvedObjects);\n\t\t\t})\n\t\t} else if (path.isCallExpression()) {\n\t\t\tconst callee = path.get(\"callee\");\n\t\t\tlet resolvedCallees = [];\n\t\t\tthis.collectExpressionInformation(callee);\n\t\t\tcallee.node.extra.results.forEach(func => {\n\t\t\t\tthis.collectExpressionInformation(func);\n\t\t\t\tconst body = func.get(\"body\");\n\t\t\t\tif (!body.isBlockStatement()) {\n\t\t\t\t\t// slim arrow function        \n\t\t\t\t\tthis.collectExpressionInformation(body);\n\t\t\t\t\tresults.push(body.node.extra.results);\n\t\t\t\t} else {\n\t\t\t\t\tfunc.node.extra.returns.forEach(returnStatement => {\n\t\t\t\t\t\tthis.collectExpressionInformation(returnStatement);\n\t\t\t\t\t\tresults.push(returnStatement.node.extra.results);\n            resolvedObjects.push(returnStatement.node.extra.resolvedObjects);\n\t\t\t\t\t})\n\t\t\t\t}\n\t\t\t\t// hey we found a callee as well. \n\t\t\t\tresolvedCallees.push(func);\n\t\t\t})\n\t\t\tpath.node.extra.resolvedCallees = resolvedCallees.flat();\n\n\t\t} else if (path.isMemberExpression()) {\n\t\t\tconst objExpr = path.get(\"object\");\n\t\t\tthis.collectExpressionInformation(objExpr);\n\n\t\t\tlet tmp = objExpr.node.extra.resolvedObjects.flat();\n\t\t\ttmp.forEach(result => {\n\t\t\t\tthis.assignmentsOf(path.get(\"property\").node.name, result).forEach(assignment => {\n\t\t\t\t\tthis.collectExpressionInformation(assignment);\n\t\t\t\t\tresults.push(assignment.node.extra.results);\n          resolvedObjects.push(assignment.node.extra.resolvedObjects);\n\t\t\t\t})\n\t\t\t});\n\t\t}\n    path.node.extra.resolvedObjects = resolvedObjects.flat();\n\t\tpath.node.extra.results = results.flat();\n\t}\n  \n  // Returns for a given 'property' and {ObjExpression, [Binding]} all known assignments including the declaration\n\tassignmentsOf(property, obj) {\n    \n    let result = [];\n    this.shadowedBindings(obj.bindings).forEach(binding=>{\n    \n      let propertyEntry = this.memberAssignments.get(property) || new Map();\n      let memberDependencies = propertyEntry.get(\"misc\") || [];\n      memberDependencies.forEach(assignment => result.push(assignment));\n\n      let objEntry = propertyEntry.get(binding);\n      if (objEntry) {\n        objEntry.forEach(assignment => result.push(assignment))\n      }\n    });    \n    \n    // try to read as much from the given ObjectExpression as possible\n\t\tlet objExpr = obj.objectExpression; // the nodePath\n    if (objExpr && objExpr.isObjectExpression()){\n      let tmp = objExpr\n        .get(\"properties\")\n        .find(path => path.get(\"key\").node.name === property);\n      if(tmp) {\n        if (tmp.isObjectProperty()) {\n          result.push(tmp.get(\"value\"));\n        } else if (tmp.isObjectMethod()) {\n          result.push(tmp);\n        }\n      }\n    }\n\t\treturn result;\n\t}\n  \n  assignedValue(path) {\n    if (path.isUpdateExpression()) return path;\n    if (path.isFunctionDeclaration()) return path;\n    if (path.isAssignmentExpression()) return path.get(\"right\");\n    if (path.isVariableDeclarator()) {\n      const id = path.get(\"id\");\n      if (id.isPattern()) return; // #TODO\n      return path.get(\"init\");\n    }\n    return;\n  }\n  \n  \n  /* returns all [binding] that the input [binding] may be assigned to.\n   * ATTENTION: this only works for object bindings, since literal values are copied in javascript\n   * `let a = 4; let b = a` `b` is not shadowed but if `a` is an object, then it is shadowed, so instead of using the actual binding `b`, we use every binding `b` resolves to (including `b`)\n   * \n   * //Where is b changed?\n   * let a = {x:1};\n   * let b = a; // a is shadowed binding\n   * a.x = 2; //<--!!!\n   * //b is equal to {x:2}\n   */\n  shadowedBindings(bindings) {\n    \n    /* this should be stored in the members map or in an extra property. \n    * DOES NOT DETECT DEPENDENCIES THROUGH SIMPLE ASSIGNMENTS (a la `a = b`)\n    * do this with extra sweep as last enrichment step, when the new property in there\n    */\n    let result = bindings;\n    bindings.forEach(binding=>{\n      binding.path.node.extra.resolvedObjects.forEach(obj=>{\n        if(obj.bindings) {\n          obj.bindings.forEach(item => result.add(item));\n        }\n      })\n    });\n    \n    return result;\n  }\n  \n /* returns a set of nodes where the active Expression on this location may be changed\n  * DOES NOT care for execution order of the code\n  * uses heuristics e.g. fixed recursion depth\n  */\n\tresolveDependencies(path) {\n    if (!this.ensureEnrichment()) return new Set();\n\n    if (path.node.dependencies != null) {\n      return path.node.dependencies;\n    }\n    \n\t\treturn this._resolveDependencies(path);\n\t}\n  \n\t_resolveDependencies(path) {\n    const self = this;\n\t\tif ((path.node.extra.visited -= 1) <= 0) {\n\t\t\treturn path.node.extra.dependencies || new Set();\n\t\t}\n\n\t\tif (path.node.extra.dependencies) {\n\t\t\t// the dependencies were already collected... just return them\n\t\t\treturn path.node.extra.dependencies\n\t\t}\n\n\t\tlet dependencies = new Set([...this.shadowedBindings(path.node.extra.leakingBindings)].map(binding => [...binding.constantViolations]).flat());\n\t\tpath.node.extra.callExpressions.forEach(callExpression => {\n\t\t\tcallExpression.node.extra.resolvedCallees.forEach(callee => {\n\t\t\t\tif (t.isFunction(callee)) {\n\t\t\t\t\tthis._resolveDependencies(callee).forEach(dep => dependencies.add(dep));\n\t\t\t\t}\n\n\t\t\t\tif (t.isAssignmentExpression(callee)) {\n\t\t\t\t\tconst value = this.assignedValue(callee);\n\t\t\t\t\tif (t.isFunction(value) || t.isArrowFunctionExpression(value)) {\n\t\t\t\t\t\tthis._resolveDependencies(value).forEach(dep => dependencies.add(dep));\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (t.isVariableDeclarator(callee)) {\n\t\t\t\t\t//NOP\n\t\t\t\t}\n\t\t\t})\n\t\t});\n\n\t\tif (path.node.extra.objects.size) {\n\t\t\tfor (const [objExpr, members] of path.node.extra.objects.entries()) {\n        if (t.isThisExpression(objExpr)) continue;\n\t\t\t\tfor (const member of members) {\n            self.assignmentsOf(member, {bindings: new Set([objExpr.extra.binding])}).forEach(assignment => {\n\t\t\t\t\t\tdependencies.add(assignment)\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpath.node.extra.dependencies = dependencies;\n\t\treturn dependencies;\n\t}\n  \n  getAllActiveExpressions() {\n    return this.aexprs || (this.aexprs = this._collectAExprs());\n  }\n  \n  _collectAExprs() {\n    const allAExpr = [];\n    this.programPath.traverse({\n      CallExpression(path) {\n        if (isAExpr(path) ) {\n          allAExpr.push(path);\n        }\n      }\n    });    \n    return allAExpr;    \n  }\n\n}\n\n/*MD ## Active Expressions Helper*/\n\nconst AEXPR_IDENTIFIER_NAME = 'aexpr';\n\nfunction leakingBindings(path) {\n\tconst bindings = new Set;\n\tpath.traverse({\n\t\tReferencedIdentifier(id) {\n\t\t\tconst outerBinding = path.scope.getBinding(id.node.name);\n\t\t\tif (!outerBinding) return;\n\t\t\tconst actualBinding = id.scope.getBinding(id.node.name);\n\t\t\tif (outerBinding === actualBinding) {\n\t\t\t\tbindings.add(actualBinding);\n\t\t\t}\n\t\t}\n\t});\n\treturn bindings;\n}\n\nfunction isAExpr(path) {\n\treturn t.isCallExpression(path)\n\t\t&& t.isIdentifier(path.node.callee)\n\t\t&& path.node.callee.name === AEXPR_IDENTIFIER_NAME\n\t\t&& !path.scope.hasBinding(AEXPR_IDENTIFIER_NAME, true);\n}\n"]}