{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-jens/src/components/widgets/lively-code-mirror-ast-capabilities.js"],"names":["loc","range","fileEnding","replaceFileEndingWith","boundEval","ContextMenu","FileIndex","babelDefault","babel","t","types","template","ASTCapabilities","constructor","livelyCodeMirror","codeMirror","codeChanged","editor","selectionRanges","listSelections","length","firstSelection","map","_getFirstSelectionOrCursorPosition","anchor","getCursor","head","programPath","myProgramPath","parsingFailed","programPathFor","sourceCode","code","traverseAsAST","Program","path","err","undefined","rootNode","parent","updateColorPicker","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","asCM","isStringLiteral","ch","setSelection","setSelections","scrollIntoView","from","to","paths","ClassMethod","key","FunctionDeclaration","id","ClassDeclaration","getColorLiterals","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","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","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","openMenu","fa","modifiers","m","myself","generateGenerationSubmenu","submenu","menu","remove","generateClass","unshift","generateTestCase","generateGetter","generateSetter","generateImportSubmenu","replace","lively4url","addImport","menuItems","extractExpressionIntoLocalVariable","wrapExpressionIntoActiveExpression","extractMethod","selectMethodExtraction","changedSelectionInMenu","undoSelection","generateHTMLAccessors","menuPosition","cursorCoords","openIn","document","body","clientX","left","clientY","bottom","addEventListener","focusEditor","openHTMLAccessorsMenu","initialSelectionState","getExistingAccessors","classMethodIdentifier","ExportDefaultDeclaration","compileListOfIDs","existingMethods","generateMethodNameFromProperty","selectedItems","warn","item","generateCodeFragment","compileHTMLGetter","allParents","ele","tagName","jsURI","encodeURI","shadowRoot","querySelector","htmlURI","html","fetchText","tmp","innerHTML","childNodes","content","querySelectorAll","ea","htmlLines","idsWithLocation","indexOfId","compileTestCase","compileGetter","compileSetter","compileClass","replacementGenerator","scrollInfo","identifierObject","generatedCode","transformAsAST","visitor","pathBefore","pathWithin","unshiftContainer","insertAfter","pathToSelect","scrollTo","explanation","EXP","stringLiteral","propertyName","blockStatement","returnStatement","memberExpression","thisExpression","expressionStatement","assignmentExpression","className","classDeclaration","classBody","property","methodName","callExpression","getUserInput","description","defaultValue","input","prompt","Promise","resolve","reject","importName","isFunction","existingImportStatement","isImportDeclaration","source","importStatement","importDeclaration","importSpecifier","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","methodCall","awaitExpression","variableType","variableDeclaration","variableDeclarator","objectPattern","replaceWithMultiple","transformed","parameters","pathsToSelect","silent","expressions","done","pathLocationToBeExtracted","res","isSelectedPath","getPathLocation","ensureBlock","statements","blockNode","isArrowFunctionExpression","Error","targetLocation","blockLocation","parentKey","isFor","isWhile","becameABlock","isIfStatement","pathLocationsToSelect","resultExtracted","pathByLocationFromProgram","generateUidIdentifier","decl","ID","INIT","referree","insertedDeclaration","getStatementParent","insertBefore","insertedDeclarationIdentifier","get","pathLocationsToPathes","ae","EXPR","expression","getScrollInfo","top","right","width","height","selections","pathRange","location","reg","result","exec","part","startsWith","parseInt","pathLocations","possibleClasses","methods","me","possibleExports","exports","where","anyOf","locations","e","eCl","exp","pPath","old","getAllMarks","marker","clear","colorLiterals","picker","createElement","bookmark","setBookmark","event","currentLocation","updateColor","target","color","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;AAYLC,gB,UAAAA,U;AAAYC,2B,UAAAA,qB;;AAVdC,e;;AACAC,iB;;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,gBAAZ,EAA8BC,UAA9B,EAA0C;AACxC,eAAKD,gBAAL,GAAwBA,gBAAxB;AACA,eAAKC,UAAL,GAAkBA,UAAlB;AACA,cAAI,CAACA,UAAL,EAAiB;AACjB,eAAKC,WAAL;AACD;;AAED,YAAIC,MAAJ,GAAa;AACX,iBAAO,KAAKF,UAAZ;AACD;;AAED,YAAIG,eAAJ,GAAsB;AACpB,cAAI,KAAKD,MAAL,CAAYE,cAAZ,GAA6BC,MAA7B,IAAuC,CAA3C,EAA8C;AAC5C,mBAAO,KAAKC,cAAZ;AACD;AACD,iBAAO,KAAKJ,MAAL,CAAYE,cAAZ,GAA6BG,GAA7B,CAAiCrB,KAAjC,CAAP;AACD;;AAED,YAAIoB,cAAJ,GAAqB;AACnB,iBAAOpB,MAAM,KAAKsB,kCAAL,EAAN,CAAP;AACD;;AAEDA,6CAAqC;AACnC,cAAI,KAAKN,MAAL,CAAYE,cAAZ,GAA6BC,MAA7B,IAAuC,CAA3C,EAA8C;AAC5C,mBAAO,EAAEI,QAAQ,KAAKP,MAAL,CAAYQ,SAAZ,EAAV,EAAmCC,MAAM,KAAKT,MAAL,CAAYQ,SAAZ,EAAzC,EAAP;AACD;AACD,iBAAO,KAAKR,MAAL,CAAYE,cAAZ,GAA6B,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;;AAEDvB,sBAAc;AACZ,eAAKY,aAAL,GAAqBS,SAArB;AACA,eAAKR,aAAL,GAAqB,IAArB;AACA,eAAKW,iBAAL;AACA,eAAKC,kBAAL,GAA0B,KAA1B;AACA,eAAKC,iBAAL,GAAyB,IAAIC,GAAJ,EAAzB;AACA,eAAKC,MAAL,GAAcP,SAAd;AACD;;AAED,YAAIQ,QAAJ,GAAe;AACb,cAAI,KAAKhB,aAAL,IAAsB,IAA1B,EAAgC,KAAKF,WAAL;AAChC,iBAAO,CAAC,KAAKE,aAAb;AACD;;AAED;;;AAGAiB,iBAASC,YAAT,EAAuBC,OAAvB,EAAgC;AAC9B,cAAIC,UAAJ;;AAEAF,uBAAaG,QAAb,CAAsB;AACpBC,kBAAMhB,IAAN,EAAY;AACV,kBAAI,CAACc,UAAD,IAAeD,QAAQb,IAAR,CAAnB,EAAkC;AAChCc,6BAAad,IAAb;AACAA,qBAAKiB,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,kBAAMhB,IAAN,EAAY;AACV,kBAAI,CAACqB,KAAL,EAAY;AACVA,wBAAQrB,IAAR;AACD;AACF;AALmB,WAAtB;AAOA,iBAAOqB,SAAST,YAAhB;AACD;;AAED;;;AAGAU,4BAAoBV,YAApB,EAAkCvB,MAAlC,EAA0C;AACxC,gBAAMkC,iBAAiB1D,IAAIwB,MAAJ,CAAvB;AACA,cAAImC,SAAJ;AACAZ,uBAAaG,QAAb,CAAsB;AACpBU,iBAAKzB,IAAL,EAAW;AACT,oBAAM0B,eAAe1B,KAAK2B,IAAL,CAAU9D,GAA/B;AACA,oBAAM+D,UAAU/D,IAAI6D,aAAaG,GAAjB,CAAhB;AACA,kBAAIN,eAAeO,QAAf,CAAwBF,OAAxB,CAAJ,EAAsC;AACpC5B,qBAAKiB,IAAL;AACA;AACD;AACDO,0BAAYxB,IAAZ;AACD;AATmB,WAAtB;AAWA,iBAAOwB,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+BlC,QAAQ;AAC5C,qBAAOlC,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,EAAqBsE,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,yBAAiB7C,WAAjB,EAA8B;AAC5B,iBAAO,KAAKT,eAAL,CAAqBI,GAArB,CAAyB6C,aAAa;AAC3C,kBAAMM,+BAA+B,KAAKP,mCAAL,CAAyCvC,WAAzC,EAAsDwC,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,oBAAMhB,IAAN,EAAY;AACV,oBAAIgC,UAAUS,oBAAV,CAA+B3E,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAA/B,CAAJ,EAA0D;AACxD2E,gCAAcE,IAAd,CAAmB1C,IAAnB;AACD;AACDA,qBAAK2C,IAAL;AACD;AANmC,aAAtC;AAQA,mBAAOH,aAAP;AACD,WAnBM,EAmBJI,IAnBI,EAAP;AAoBD;;AAEDC,8BAAsBrD,WAAtB,EAAmC;AACjC,iBAAO,KAAKT,eAAL,CAAqBI,GAArB,CAAyB6C,aAAa;AAC3C;AACA,kBAAMM,+BAA+B,KAAKQ,4DAAL,CAAkEtD,WAAlE,EAA+EwC,SAA/E,CAArC;;AAEA,gBAAI1D,EAAEyE,WAAF,CAAcT,4BAAd,KAA+C,CAAChE,EAAE0E,gBAAF,CAAmBV,4BAAnB,CAApD,EAAsG;AACpG,qBAAOA,4BAAP;AACD;;AAED;AACA,gBAAIE,gBAAgB,EAApB;AACAF,yCAA6BvB,QAA7B,CAAsC;AACpCkC,wBAAUjD,IAAV,EAAgB;AACd,oBAAIgC,UAAUS,oBAAV,CAA+B3E,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAA/B,CAAJ,EAA0D;AACxD2E,gCAAcE,IAAd,CAAmB1C,IAAnB;AACD;AACDA,qBAAK2C,IAAL;AACD;AANmC,aAAtC;AAQA,mBAAOH,aAAP;AACD,WAnBM,EAmBJI,IAnBI,EAAP;AAoBD;;AAEDM,+BAAuB1D,WAAvB,EAAoC;AAClC,iBAAO,KAAKT,eAAL,CAAqBI,GAArB,CAAyB6C,aAAa;AAC3C;AACA,kBAAMM,+BAA+B,KAAKQ,4DAAL,CAAkEtD,WAAlE,EAA+EwC,SAA/E,CAArC;;AAEA,gBAAI1D,EAAE6E,YAAF,CAAeb,4BAAf,KAAgD,CAAChE,EAAE8E,YAAF,CAAed,4BAAf,CAArD,EAAmG;AACjG,qBAAOA,4BAAP;AACD;AACD;AACA,gBAAIE,gBAAgB,EAApB;AACAF,yCAA6BvB,QAA7B,CAAsC;AACpCsC,yBAAWrD,IAAX,EAAiB;AACf,oBAAIgC,UAAUS,oBAAV,CAA+B3E,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAA/B,KAAwD,CAACS,EAAE8E,YAAF,CAAepD,IAAf,CAA7D,EAAmF;AACjFwC,gCAAcE,IAAd,CAAmB1C,IAAnB;AACD;AACDA,qBAAK2C,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,CAAuBvD,QAAQ;AAC7B,gBAAIgC,UAAUwB,OAAV,CAAkB1F,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAAlB,CAAJ,EAA6C;AAC3CyF,4BAActD,IAAd;AACD;AACD,mBAAO,KAAP;AACD,WALD;AAMA,iBAAOsD,WAAP;AACD;;AAED;;;AAGAG,oBAAYC,UAAZ,EAAwB;AACtB,gBAAMC,qBAAqB,EAA3B;AACAD,qBAAW3C,QAAX,CAAoB;AAClBU,iBAAKzB,IAAL,EAAW;AACT2D,iCAAmBjB,IAAnB,CAAwB1C,IAAxB;AACD;AAHiB,WAApB;AAKA,iBAAO2D,kBAAP;AACD;AACD;;;AAGAC,qBAAaF,UAAb,EAAyB;AACvB,gBAAMC,qBAAqB,EAA3B;AACAD,qBAAW3C,QAAX,CAAoB;AAClBC,kBAAMhB,IAAN,EAAY;AACV2D,iCAAmBjB,IAAnB,CAAwB1C,IAAxB;AACD;AAHiB,WAApB;AAKA,iBAAO2D,mBAAmBE,OAAnB,EAAP;AACD;AACD;;;;AAIAC,8BAAsBC,SAAtB,EAAiCC,QAAjC,EAA2C;AACzC,gBAAMxE,cAAc,KAAKA,WAAzB;AACA,gBAAMyE,WAAWD,WAAW,KAAKJ,YAAL,CAAkBpE,WAAlB,CAAX,GAA4C,KAAKiE,WAAL,CAAiBjE,WAAjB,CAA7D;;AAEA,gBAAM0E,WAAW,KAAKnF,eAAL,CAAqBI,GAArB,CAAyB6C,aAAa;;AAErD,kBAAMsB,cAAc,KAAKR,4DAAL,CAAkEtD,WAAlE,EAA+EwC,SAA/E,CAApB;;AAEA;AACA,gBAAIA,UAAUwB,OAAV,CAAkB1F,MAAMwF,YAAY3B,IAAZ,CAAiB9D,GAAvB,CAAlB,CAAJ,EAAoD;AAClD,qBAAO,KAAKsG,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,cAAIhG,EAAE8E,YAAF,CAAekB,UAAU3C,IAAzB,CAAJ,EAAoC;AAClC,mBAAO2C,SAAP;AACD;AACD,cAAIC,KAAJ;AACAD,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWxE,IAAX,EAAiB;AACf,kBAAI,CAACuE,KAAL,EAAY;AACVA,wBAAQvE,IAAR;AACAA,qBAAKiB,IAAL;AACD;AACF;AANgB,WAAnB;AAQA,iBAAOsD,KAAP;AACD;;AAEDE,2CAAmCH,SAAnC,EAA8CI,IAA9C,EAAoD;AAClD,cAAIpG,EAAE8E,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,uBAAWxE,IAAX,EAAiB;AACf,kBAAI,CAACuE,KAAD,IAAUjG,EAAE8E,YAAF,CAAepD,KAAK2B,IAApB,EAA0B,EAAE+C,MAAMA,IAAR,EAA1B,CAAd,EAAyD;AACvDH,wBAAQvE,IAAR;AACAA,qBAAKiB,IAAL;AACD;AACF;AANgB,WAAnB;AAQA,iBAAOsD,KAAP;AACD;;AAEDI,0BAAkBL,SAAlB,EAA6B;AAC3B,cAAIM,cAAc,EAAlB;AACA;;;AAGAN,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWxE,IAAX,EAAiB;AACf4E,0BAAYlC,IAAZ,CAAiB1C,IAAjB;AACD;AAHgB,WAAnB;AAKA,iBAAO4E,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,EAAkD1E,IAAzD;AACD;AACF;;AAEDkF,4CAAoCC,OAApC,EAA6C;AAC3C,iBAAO,KAAKV,kCAAL,CAAwCU,QAAQnF,IAAhD,EAAsDmF,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,CAA2BxG,GAA3B,CAA+ByG,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,iBAAOtF,SAAP;AACD;;AAEDqF,yBAAiBT,UAAjB,EAA6B;AAC3B,cAAIxG,EAAEwH,kBAAF,CAAqBhB,WAAW1E,MAAhC,CAAJ,EAA6C;AAC3C,gBAAI9B,EAAEyH,gBAAF,CAAmBjB,WAAW1E,MAAX,CAAkB4F,MAArC,CAAJ,EAAkD;AAChD,kBAAIC,YAAY,KAAKC,YAAL,CAAkB,KAAK1G,WAAvB,CAAhB;AACA,kBAAI2G,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,IAAIxG,EAAEiI,aAAF,CAAgBzB,WAAW1E,MAA3B,CAAJ,EAAwC;AAC7C,mBAAO,KAAKiG,sBAAL,CAA4BvB,WAAWpB,UAAvC,CAAP;AACD;AACF;;AAED2C,+BAAuBG,WAAvB,EAAoC;AAClC,cAAIC,gBAAJ;AACAD,sBAAYzF,QAAZ,CAAqB;AACnByD,uBAAWxE,IAAX,EAAiB;AACfA,mBAAKiB,IAAL;AACAwF,iCAAmBzG,IAAnB;AACD;AAJkB,WAArB;AAMA,iBAAO,CAACyG,gBAAD,EAAmB,GAAG,KAAKH,iBAAL,CAAuBG,gBAAvB,CAAtB,CAAP;AACD;;AAED;;;AAGAH,0BAAkBxB,UAAlB,EAA8B4B,aAAa,KAA3C,EAAkDpC,YAAY,KAAK9E,WAAnE,EAAgF;AAC9E,cAAImH,UAAU,EAAd;AACArC,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWxE,IAAX,EAAiB;AACf,kBAAI1B,EAAEwH,kBAAF,CAAqB9F,KAAKI,MAA1B,KAAqCJ,KAAK2B,IAAL,CAAU+C,IAAV,KAAmBI,WAAWnD,IAAX,CAAgB+C,IAA5E,EAAkF;AAChF,oBAAIpG,EAAEyH,gBAAF,CAAmB/F,KAAKI,MAAL,CAAY4F,MAA/B,KAA0C,CAACU,UAA/C,EAA2D;AACzDC,0BAAQjE,IAAR,CAAa1C,IAAb;AACD,iBAFD,MAEO,IAAI0G,UAAJ,EAAgB;AACrBC,0BAAQjE,IAAR,CAAa1C,IAAb;AACD;AACF;AACF;AATgB,WAAnB;AAWA,iBAAO2G,OAAP;AACD;;AAEDC,qCAA6BtC,YAAY,KAAK9E,WAA9C,EAA2D;AACzD,cAAIqH,qBAAqB,EAAzB;AACAvC,oBAAUvD,QAAV,CAAmB;AACjByD,uBAAWxE,IAAX,EAAiB;AACf,kBAAI1B,EAAEwH,kBAAF,CAAqB9F,KAAKI,MAA1B,CAAJ,EAAuC;AACrC,oBAAI,CAAC9B,EAAEyH,gBAAF,CAAmB/F,KAAKI,MAAL,CAAY4F,MAA/B,CAAL,EAA6C;AAC3Ca,qCAAmBnE,IAAnB,CAAwB1C,IAAxB;AACD;AACF;AACF;AAPgB,WAAnB;AASA,iBAAO6G,mBAAmB1H,GAAnB,CAAuBgG,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,EAA8CjE,IAA9C,EAAoD;AAClD,gBAAMmH,oBAAoBlD,SAASmD,IAAT,CAAcC,cAAcA,WAAW1F,IAAX,KAAoB3B,KAAK2B,IAArD,CAA1B;AACA,gBAAM2F,eAAerD,SAASiD,OAAT,CAAiBC,iBAAjB,CAArB;AACA,eAAK,IAAII,IAAID,eAAe,CAA5B,EAA+BC,IAAItD,SAAShF,MAA5C,EAAoDsI,GAApD,EAAyD;AACvD,gBAAIxD,UAAU/D,IAAV,EAAgBiE,SAASsD,CAAT,CAAhB,CAAJ,EAAkC;AAChC,qBAAOtD,SAASsD,CAAT,CAAP;AACD;AACF;AACD,iBAAOtD,SAASA,SAAShF,MAAT,GAAkB,CAA3B,CAAP;AACD;;AAED;;;AAGAuI,oBAAYC,KAAZ,EAAmBC,2BAA2B,KAA9C,EAAqD;AACnD,gBAAMC,SAASF,MAAMtI,GAAN,CAAUwC,QAAQ;AAC/B,kBAAM,CAACtC,MAAD,EAASE,IAAT,IAAiBzB,MAAM6D,KAAK9D,GAAX,EAAgB+J,IAAhB,EAAvB;AACA,gBAAIF,4BAA4BpJ,EAAEuJ,eAAF,CAAkBlG,IAAlB,CAAhC,EAAyD;AACvDtC,qBAAOyI,EAAP;AACAvI,mBAAKuI,EAAL;AACD;AACD,mBAAO,EAAEzI,MAAF,EAAUE,IAAV,EAAP;AACD,WAPc,CAAf;AAQA;AACA,cAAIoI,OAAO1I,MAAP,IAAiB,CAArB,EAAwB;AACtB,iBAAKH,MAAL,CAAYiJ,YAAZ,CAAyBJ,OAAO,CAAP,EAAUpI,IAAnC,EAAyCoI,OAAO,CAAP,EAAUtI,MAAnD;AACD,WAFD,MAEO;AACL,iBAAKP,MAAL,CAAYkJ,aAAZ,CAA0BL,MAA1B;AACD;AACD,eAAK/I,UAAL,CAAgBqJ,cAAhB,CAA+B,EAAEC,MAAMP,OAAO,CAAP,EAAUpI,IAAlB,EAAwB4I,IAAIR,OAAO,CAAP,EAAUtI,MAAtC,EAA/B,EAA+E,GAA/E;AACD;;AAED;;;AAGA+E,oBAAYgE,KAAZ,EAAmBV,2BAA2B,KAA9C,EAAqD;AACnD,eAAKF,WAAL,CAAiBY,MAAMjJ,GAAN,CAAUa,QAAQA,KAAK2B,IAAvB,CAAjB,EAA+C+F,wBAA/C;AACD;;AAED;;;AAGAtB,sBAAc5G,WAAd,EAA2BkF,IAA3B,EAAiC;AAC/B,cAAIyB,UAAJ;AACA3G,sBAAYuB,QAAZ,CAAqB;AACnBsH,wBAAYrI,IAAZ,EAAkB;AAChB,kBAAI,CAACmG,UAAD,IAAenG,KAAK2B,IAAL,CAAU2G,GAAV,CAAc5D,IAAd,IAAsBA,IAAzC,EAA+C;AAC7CyB,6BAAanG,IAAb;AACD;AACF,aALkB;AAMnBuI,gCAAoBvI,IAApB,EAA0B;AACxB,kBAAI,CAACmG,UAAD,IAAenG,KAAK2B,IAAL,CAAU6G,EAAV,CAAa9D,IAAb,IAAqBA,IAAxC,EAA8C;AAC5CyB,6BAAanG,IAAb;AACD;AACF;AAVkB,WAArB;AAYA,iBAAOmG,UAAP;AACD;;AAED;;;AAGAD,qBAAa1G,WAAb,EAA0B;AACxB,cAAIyG,SAAJ;AACAzG,sBAAYuB,QAAZ,CAAqB;AACnB0H,6BAAiBzI,IAAjB,EAAuB;AACrB,kBAAI,CAACiG,SAAL,EAAgB;AACdA,4BAAYjG,IAAZ;AACD;AACF;AALkB,WAArB;AAOA,iBAAOiG,SAAP;AACD;;AAEDyC,yBAAiBlJ,WAAjB,EAA8B;AAC5B,cAAImJ,aAAa,EAAjB;AACA,gBAAMC,aAAa,2BAAnB;AACApJ,sBAAYuB,QAAZ,CAAqB;AACnB8H,0BAAc7I,IAAd,EAAoB;AAClB,kBAAIA,KAAK2B,IAAL,CAAUoF,KAAV,CAAgB+B,KAAhB,CAAsBF,UAAtB,CAAJ,EAAuC;AACrCD,2BAAWjG,IAAX,CAAgB1C,IAAhB;AACD;AACF;AALkB,WAArB;AAOA,iBAAO2I,UAAP;AACD;;AAED;;AAEAI,0BAAkB;AAChB,gBAAM7E,WAAW,KAAKnF,eAAL,CAAqBI,GAArB,CAAyB6C,aAAa;AACrD,kBAAMlB,aAAa,KAAKiB,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2DwC,SAA3D,CAAnB;;AAEA;AACA,mBAAOlB,WAAWsG,IAAX,CAAgBpH,QAAQ;AAC7B,qBAAOlC,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,EAAqBmL,qBAArB,CAA2ChH,SAA3C,CAAP;AACD,aAFM,KAEDlB,UAFN;AAGD,WAPgB,CAAjB;;AASA,eAAKsD,WAAL,CAAiBF,QAAjB;AACD;;AAED+E,0BAAkB;AAChB,gBAAM/E,WAAW,KAAKnF,eAAL,CAAqBI,GAArB,CAAyB6C,aAAa;AACrD,kBAAMlB,aAAa,KAAKiB,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2DwC,SAA3D,CAAnB;;AAEA,mBAAO,KAAKZ,mBAAL,CAAyBN,UAAzB,CAAP;AACD,WAJgB,CAAjB;;AAMA,eAAKsD,WAAL,CAAiBF,QAAjB;AACD;;AAEDgF,2BAAmBlF,QAAnB,EAA6B;AAC3B,iBAAO,KAAKF,qBAAL,CAA2B,CAACqF,WAAD,EAAcC,QAAd,KAA2B;AAC3D,mBAAO9K,EAAE8E,YAAF,CAAegG,QAAf,KAA4B9K,EAAE+K,SAAF,CAAYD,QAAZ,CAA5B,IAAqD9K,EAAEyH,gBAAF,CAAmBqD,QAAnB,CAArD,IAAqF9K,EAAEgL,OAAF,CAAUF,QAAV,CAArF,IAA4G9K,EAAEiL,mBAAF,CAAsBH,QAAtB,CAAnH;AACD,WAFM,EAEJpF,QAFI,CAAP;AAGD;;AAEDwF,kCAA0BxF,QAA1B,EAAoC;AAClC,iBAAO,KAAKF,qBAAL,CAA2B,CAACqF,WAAD,EAAcC,QAAd,KAA2BD,YAAYM,IAAZ,IAAoBL,SAASK,IAAnF,EAAyFzF,QAAzF,CAAP;AACD;;AAED0F,4BAAoB1F,QAApB,EAA8B;AAC5B,gBAAM2F,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA,gBAAM0K,WAAW,KAAKxE,iBAAL,CAAuBuE,YAAvB,CAAjB,CAAsD,IAAIC,QAAJ,EAAc;AAClE,gBAAIC,iBAAiB,CAAC,GAAGD,QAAJ,EAAcE,IAAd,CAAmB,CAACC,CAAD,EAAIC,CAAJ,KAAUD,EAAEpI,IAAF,CAAOsI,KAAP,GAAeD,EAAErI,IAAF,CAAOsI,KAAnD,CAArB;AACA,gBAAIjD,QAAQ6C,eAAe3C,OAAf,CAAuByC,YAAvB,CAAZ;AACA3C,qBAAShD,WAAW,CAAC,CAAZ,GAAgB,CAAzB;AACAgD,oBAAQ,CAACA,QAAQ6C,eAAe5K,MAAxB,IAAkC4K,eAAe5K,MAAzD;AACA,iBAAKmF,WAAL,CAAiB,CAACyF,eAAe7C,KAAf,CAAD,CAAjB;AACD;AACF;;AAED,cAAMkD,iBAAN,GAA0B;AACxB,gBAAMP,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;AACA,gBAAM4F,aAAa,KAAKT,0BAAL,CAAgCsF,YAAhC,CAAnB;AACA,cAAI,CAAC7E,UAAL,EAAiB;AACf;AACD;AACD,gBAAMqF,YAAYrF,WAAWnD,IAAX,CAAgB+C,IAAlC;;AAEA,gBAAM0F,cAAc,MAAM,KAAKvF,cAAL,CAAoBC,UAApB,CAA1B;AACA;AACA,cAAIsF,eAAe,CAAC9L,EAAE+L,iBAAF,CAAoBD,WAApB,CAApB,EAAsD;AACpD,iBAAKhG,WAAL,CAAiB,CAACgG,WAAD,CAAjB;AACD,WAFD,MAEO;AACL,gBAAInE,YAAY,KAAKC,YAAL,CAAkB,KAAK1G,WAAvB,CAAhB;AACA,gBAAI2G,aAAa,KAAKC,aAAL,CAAmBH,SAAnB,EAA8BkE,SAA9B,CAAjB;AACA,gBAAIhE,UAAJ,EAAgB;AACd,mBAAKqB,WAAL,CAAiB,CAACrB,WAAWxE,IAAX,CAAgB2G,GAAjB,CAAjB;AACD,aAFD,MAEO;AACL,oBAAMgC,YAAY,MAAM,KAAKC,uBAAL,CAA6BJ,SAA7B,EAAwCK,IAAxC,CAA6CC,OAAOA,IAAItL,GAAJ,CAAQuL,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,aAAa1M,gBAAb,EAApB;AACA,sBAAI4M,KAAK,MAAMF,aAAaG,WAAb,EAAf;AACAF,gCAAcG,eAAd,CAA8BF,EAA9B,EAAkCf,IAAlC,CAAuCkB,MAAM;AAC3CA,uBAAGtH,WAAH,CAAe,CAACsH,GAAGtF,aAAH,CAAiBsF,GAAGlM,WAApB,EAAiC2K,SAAjC,CAAD,CAAf;AACD,mBAFD;AAGD,iBAND;AAOD,eARmB,CAApB;AASD;AACF;AACD;;;;AAID;;AAED,cAAMwB,MAAN,GAAe;AACb,gBAAMhC,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA,cAAI4F,aAAa,KAAKT,0BAAL,CAAgCsF,YAAhC,CAAjB;AACA,cAAI,CAAC7E,UAAL,EAAiB;AACjB,gBAAMO,cAAc,KAAKC,aAAL,CAAmBR,UAAnB,CAApB;;AAEA,cAAGO,WAAH,EAAgB;AACd,iBAAKjB,WAAL,CAAiBiB,WAAjB;AACA;AACD;;AAED,gBAAMuG,eAAe,MAAM,KAAKC,8BAAL,CAAoC/G,UAApC,CAA3B;;AAGA,cAAIgH,OAAO,MAAMb,OAAOc,qBAAP,CAA6B,iCAA7B,CAAjB;AACAD,eAAKE,KAAL;AACAF,eAAKG,kBAAL,CAAwB,MAAxB,EAAgC,gBAAhC;AACAH,eAAKI,QAAL,CAAc,YAAYpH,WAAWnD,IAAX,CAAgB+C,IAA1C;AACA,gBAAMyH,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,kBAAMtM,OAAO,MAAM4M,MAAMD,UAAU7B,GAAhB,EAAqBH,IAArB,CAA0BkC,KAAKA,EAAEC,IAAF,EAA/B,CAAnB;;AAEA,kBAAMC,YAAY/M,KAAKgN,KAAL,CAAW,IAAX,CAAlB;;AAEAC,mBAAOC,SAAP,CAAiBC,cAAjB,GAAkC,UAAS/C,KAAT,EAAgBpI,GAAhB,EAAqBoL,IAArB,EAA2B;AAC3D,qBAAO,KAAKC,SAAL,CAAe,CAAf,EAAkBjD,KAAlB,IAA2BgD,IAA3B,GAAkC,KAAKC,SAAL,CAAerL,GAAf,CAAzC;AACD,aAFD;AAGA+K,sBAAUJ,UAAUW,IAApB,IAA4BP,UAAUJ,UAAUW,IAApB,EAA0BH,cAA1B,CAAyCR,UAAU1E,EAAnD,EAAuD0E,UAAU1E,EAAV,GAAehD,WAAWnD,IAAX,CAAgB+C,IAAhB,CAAqBzF,MAA3F,EAAmGoN,OAAnG,CAA5B;;AAEA,kBAAMe,UAAUR,UAAUS,IAAV,CAAe,IAAf,CAAhB;AACA,kBAAMpC,OAAOqC,KAAP,CAAaC,QAAb,CAAsBf,UAAU7B,GAAhC,EAAqCyC,OAArC,CAAN;AACA,kBAAMnC,OAAOuC,YAAP,CAAoBhB,UAAU7B,GAA9B,CAAN;AACA,kBAAM8C,OAAOC,MAAP,CAAclB,UAAU7B,GAAxB,CAAN;AACD;AACF;;AAEDgD,yBAAiB;AACf,gBAAMhE,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA,gBAAM0K,WAAW,KAAKxE,iBAAL,CAAuBuE,YAAvB,CAAjB;AACA,cAAIC,QAAJ,EAAc;AACZ,iBAAKxF,WAAL,CAAiBwF,QAAjB;AACD;AACF;;AAED,cAAMgE,gBAAN,GAAyB;AACvB,gBAAMjE,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;;AAEA;AACA,cAAI4F,aAAa,KAAKT,0BAAL,CAAgCsF,YAAhC,CAAjB;;AAEA;AACA,gBAAMiC,eAAe,MAAM,KAAKC,8BAAL,CAAoC/G,UAApC,CAA3B;;AAEA,eAAK+I,kBAAL,CAAwBjC,YAAxB,EAAsC9G,WAAWnD,IAAX,CAAgB+C,IAAtD;AACD;;AAED,cAAMmH,8BAAN,CAAqC/G,UAArC,EAAiD;AAC/C,cAAIkC,QAAQ,MAAM7I,UAAU2P,OAAV,EAAlB;AACA,cAAIC,MAAM,MAAM/G,MAAMgH,EAAN,CAASV,KAAT,CAAexG,MAAf,CAAsBmH,QAAQ;AAC5C,gBAAI,CAACA,KAAKpH,kBAAV,EAA8B,OAAO,KAAP;AAC9B,mBAAOoH,KAAKpH,kBAAL,CAAwBqH,IAAxB,CAA6B1F,MAAMA,GAAG9D,IAAH,IAAWI,WAAWJ,IAAzD,CAAP;AACD,WAHe,EAGbyJ,OAHa,EAAhB;AAIA,gBAAMvC,eAAe,EAArB;;AAEA,eAAK,MAAMpD,EAAX,IAAiBuF,GAAjB,EAAsB;AACpB,kBAAMlO,OAAO,MAAM4M,MAAMjE,GAAGmC,GAAT,EAAcH,IAAd,CAAmBkC,KAAKA,EAAEC,IAAF,EAAxB,CAAnB;AACA,kBAAMyB,UAAU,KAAKzO,cAAL,CAAoBE,IAApB,CAAhB;AACA,iBAAK,MAAM2M,SAAX,IAAwB,KAAKlG,iBAAL,CAAuBxB,UAAvB,EAAmC,IAAnC,EAAyCsJ,OAAzC,CAAxB,EAA2E;AACzE,oBAAMjB,OAAOX,UAAU7K,IAAV,CAAe9D,GAAf,CAAmBoM,KAAnB,CAAyBkD,IAAzB,GAAgC,CAA7C;AACA,oBAAMrF,KAAK0E,UAAU7K,IAAV,CAAe9D,GAAf,CAAmBoM,KAAnB,CAAyBoE,MAApC;AACAzC,2BAAalJ,IAAb,CAAkB,EAAE8F,IAAIA,GAAGmC,GAAH,CAAOuC,SAAP,CAAiB1E,GAAGmC,GAAH,CAAO2D,WAAP,CAAmB,GAAnB,IAA0B,CAA3C,IAAgD,IAAhD,GAAuDnB,IAA7D,EAAmExC,KAAKnC,GAAGmC,GAA3E,EAAgFwC,IAAhF,EAAsFrF,EAAtF,EAAlB;AACD;AACF;;AAED,iBAAO8D,YAAP;AACD;;AAED,cAAMiC,kBAAN,CAAyBE,GAAzB,EAA8BQ,cAA9B,EAA8C;AAC5C,cAAIzC,OAAO,MAAMb,OAAOc,qBAAP,CAA6B,iCAA7B,CAAjB;AACAD,eAAKE,KAAL;AACAF,eAAKI,QAAL,CAAc,mBAAmBqC,cAAjC;AACA,iBAAOzC,KAAKM,WAAL,CAAiB2B,GAAjB,CAAP;AACD;;AAED,cAAMS,WAAN,GAAoB;AAClB,cAAIC,SAAJ,EAAeC,OAAf,EAAwBvE,SAAxB;AACA,gBAAMR,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;AACA,gBAAM4F,aAAa,KAAKT,0BAAL,CAAgCsF,YAAhC,CAAnB;AACA,cAAI7E,UAAJ,EAAgB;AACdqF,wBAAYrF,WAAWnD,IAAX,CAAgB+C,IAA5B;AACA+J,wBAAY,MAAM,KAAK5D,qBAAL,CAA2BV,SAA3B,CAAlB;AACAuE,sBAAU,MAAM,KAAKnE,uBAAL,CAA6BJ,SAA7B,CAAhB;AACD;AACD,iBAAO,EAAEA,SAAF,EAAasE,SAAb,EAAwBC,OAAxB,EAAP;AACD;AACD;;AAEA;;AAEA;AACAC,qBAAa3O,IAAb,EAAmB;AACjB,cAAI4O,eAAe,KAAKC,IAAL,CAAU,gBAAV,EAA4B7O,IAA5B,EAAkC,UAAlC,CAAnB;;AAEA,iBAAO4O,iBAAiB,IAAxB,EAA8B;AAC5B,gBAAIA,aAAajN,IAAb,IAAqBiN,aAAajN,IAAb,CAAkBmN,MAAlB,CAAyBpK,IAAzB,KAAkC,UAA3D,EAAuE;AACrE;AACD;AACDkK,2BAAe,KAAKC,IAAL,CAAU,gBAAV,EAA4BD,aAAalL,UAAzC,EAAqD,UAArD,CAAf;AACD;AACD,iBAAOkL,YAAP;AACD;;AAEDC,aAAKpF,IAAL,EAAWzJ,IAAX,EAAiB;AACf,iBAAOA,SAAS,IAAhB,EAAsB;AACpB,gBAAI,KAAK+O,YAAL,CAAkBtF,IAAlB,EAAwBzJ,IAAxB,CAAJ,EAAmC;AACjC,qBAAOA,IAAP;AACD;AACDA,mBAAOA,KAAK0D,UAAZ;AACD;AACD,iBAAO,IAAP;AACD;;AAEDqL,qBAAatF,IAAb,EAAmBzJ,IAAnB,EAAyB;AACvB,cAAIyJ,gBAAgBuF,KAApB,EAA2B;AACzB,mBAAOvF,KAAKtK,GAAL,CAAS8P,QAAQ,KAAKF,YAAL,CAAkBE,IAAlB,EAAwBjP,IAAxB,CAAjB,EAAgDkP,MAAhD,CAAuD,CAACC,IAAD,EAAOF,IAAP,KAAgBE,QAAQF,IAA/E,EAAqF,KAArF,CAAP;AACD;AACD,iBAAOjP,KAAK2B,IAAL,IAAa3B,KAAK2B,IAAL,CAAU8H,IAAV,KAAmBA,IAAvC;AACD;;AAED,cAAM2F,QAAN,GAAiB;;AAEf,mBAASC,EAAT,CAAY3K,IAAZ,EAAkB,GAAG4K,SAArB,EAAgC;AAC9B,mBAAQ,mBAAkB5K,IAAK,IAAG4K,UAAUnQ,GAAV,CAAcoQ,KAAK,QAAQA,CAA3B,EAA8BlC,IAA9B,CAAmC,GAAnC,CAAwC,QAA1E;AACD;;AAED,gBAAMmC,SAAS,IAAf;AACA;;AAEA,yBAAeC,yBAAf,GAA2C;;AAEzC,gBAAIC,UAAU,CAAC,CAAC,OAAD,EAAU,MAAM;AAC7BC,mBAAKC,MAAL;AACAJ,qBAAOK,aAAP;AACD,aAHc,EAGZ,GAHY,EAGPR,GAAG,UAAH,CAHO,CAAD,CAAd;;AAKA,kBAAM1F,eAAe6F,OAAOzN,mCAAP,CAA2CyN,OAAOhQ,WAAlD,EAA+DgQ,OAAOtQ,cAAtE,CAArB;;AAEA;AACA,gBAAIsQ,OAAOb,YAAP,CAAoBhF,YAApB,CAAJ,EAAuC;AACrC+F,sBAAQI,OAAR,CAAgB,CAAC,UAAD,EAAa,MAAM;AACjCH,qBAAKC,MAAL;AACAJ,uBAAOO,gBAAP;AACD,eAHe,EAGb,GAHa,EAGRV,GAAG,UAAH,CAHQ,CAAhB;AAID;;AAED,gBAAIG,OAAOT,YAAP,CAAoB,CAAC,WAAD,EAAc,kBAAd,CAApB,EAAuDpF,YAAvD,CAAJ,EAA0E;AACxE+F,sBAAQhN,IAAR,CAAa,CAAC,QAAD,EAAW,MAAM;AAC5BiN,qBAAKC,MAAL;AACAJ,uBAAOQ,cAAP;AACD,eAHY,EAGV,GAHU,EAGLX,GAAG,UAAH,CAHK,CAAb,EAGyB,CAAC,QAAD,EAAW,MAAM;AACxCM,qBAAKC,MAAL;AACAJ,uBAAOS,cAAP;AACD,eAHwB,EAGtB,GAHsB,EAGjBZ,GAAG,UAAH,CAHiB,CAHzB;AAOD;;AAED,mBAAOK,OAAP;AACD;;AAED,yBAAeQ,qBAAf,GAAuC;AACrC,gBAAI,EAAE/F,SAAF,EAAasE,SAAb,EAAwBC,OAAxB,KAAoC,MAAMc,OAAOhB,WAAP,EAA9C;AACA,gBAAIkB,UAAU,EAAd;AACA,gBAAI,CAACvF,SAAD,IAAcsE,UAAUxP,MAAV,IAAoB,CAApB,IAAyByP,QAAQzP,MAAR,IAAkB,CAA7D,EAAgE;AAC9DyQ,sBAAQhN,IAAR,CAAa,CAAC,MAAD,EAAS,MAAM;AAC1BiN,qBAAKC,MAAL;AACD,eAFY,EAEV,EAFU,EAEN,EAFM,CAAb;AAGD,aAJD,MAIO;AACLnB,wBAAUzD,OAAV,CAAkBL,OAAO+E,QAAQhN,IAAR,CAAa,CAACiI,IAAIwF,OAAJ,CAAYC,UAAZ,EAAwB,EAAxB,CAAD,EAA8B,MAAM;AACxET,qBAAKC,MAAL;AACAJ,uBAAOa,SAAP,CAAiB1F,GAAjB,EAAsBR,SAAtB,EAAiC,IAAjC;AACD,eAHqC,EAGnC,GAHmC,EAG9BkF,GAAG,gBAAH,CAH8B,CAAb,CAAzB;AAIAX,sBAAQ1D,OAAR,CAAgBN,MAAMgF,QAAQhN,IAAR,CAAa,CAACgI,GAAGhG,IAAH,GAAU,IAAV,GAAiBgG,GAAGC,GAAH,CAAOwF,OAAP,CAAeC,UAAf,EAA2B,EAA3B,CAAlB,EAAkD,MAAM;AACzFT,qBAAKC,MAAL;AACAJ,uBAAOa,SAAP,CAAiB3F,GAAGC,GAApB,EAAyBD,GAAGhG,IAA5B,EAAkC,KAAlC;AACD,eAHkC,EAGhC,GAHgC,EAG3B2K,GAAG,gBAAH,CAH2B,CAAb,CAAtB;AAID;AACD,mBAAOK,OAAP;AACD;;AAED;;AAEA,gBAAMY,YAAY,CAAC,CAAC,6BAAD,EAAgC,MAAM;AACvDX,iBAAKC,MAAL;AACA,iBAAKW,kCAAL;AACD,WAHkB,EAGhB,GAHgB,EAGXlB,GAAG,gBAAH,EAAqB,iBAArB,CAHW,CAAD,EAGgC,CAAC,6BAAD,EAAgC,MAAM;AACtFM,iBAAKC,MAAL;AACA,iBAAKY,kCAAL;AACD,WAHiD,EAG/C,GAH+C,EAG1CnB,GAAG,UAAH,CAH0C,CAHhC,EAMO,CAAC,QAAD,EAAW,MAAM;AACxCM,iBAAKC,MAAL;AACA,iBAAKjE,MAAL;AACD,WAHwB,EAGtB,OAHsB,EAGb0D,GAAG,UAAH,CAHa,CANP,EASW,CAAC,gBAAD,EAAmB,MAAM;AACpDM,iBAAKC,MAAL;AACA,iBAAKa,aAAL;AACD,WAH4B,EAG1B,OAH0B,EAGjBpB,GAAG,UAAH,CAHiB,EAGD,MAAM;AAChC,kBAAMrN,YAAY,KAAK0O,sBAAL,CAA4B,KAAKlR,WAAjC,EAA8C,IAA9C,CAAlB;AACA,gBAAIwC,SAAJ,EAAe;AACb,mBAAK2O,sBAAL,GAA8B,IAA9B;AACA,mBAAKvM,WAAL,CAAiBpC,UAAUQ,aAA3B;AACD,aAHD,MAGO;AACL,mBAAKmO,sBAAL,GAA8B,KAA9B;AACD;AACF,WAX4B,EAW1B,MAAM;AACP,gBAAI,KAAKA,sBAAT,EAAiC;AAC/B,mBAAK7R,MAAL,CAAY8R,aAAZ;AACD;AACF,WAf4B,CATX,EAwBd,CAAC,yBAAD,EAA4B,MAAM;AACpCjB,iBAAKC,MAAL;AACA,iBAAKiB,qBAAL;AACD,WAHG,EAGD,OAHC,EAGQxB,GAAG,UAAH,CAHR,CAxBc,EA2BW,CAAC,kBAAD,EAAqB,MAAM;AACtD,iBAAKzB,gBAAL;AACA+B,iBAAKC,MAAL;AACD,WAH4B,EAG1B,OAH0B,EAGjBP,GAAG,UAAH,CAHiB,CA3BX,EA8BW,CAAC,UAAD,EAAaI,2BAAb,CA9BX,EA8BsD,CAAC,QAAD,EAAWS,uBAAX,CA9BtD,CAAlB;AA+BA,cAAIY,eAAe,KAAKlS,UAAL,CAAgBmS,YAAhB,CAA6B,KAA7B,EAAoC,QAApC,CAAnB;;AAEA,gBAAMpB,OAAO,MAAMzR,YAAY8S,MAAZ,CAAmBC,SAASC,IAA5B,EAAkC,EAAEC,SAASL,aAAaM,IAAxB,EAA8BC,SAASP,aAAaQ,MAApD,EAAlC,EAAgGpR,SAAhG,EAA2G+Q,SAASC,IAApH,EAA0HZ,SAA1H,CAAnB;AACAX,eAAK4B,gBAAL,CAAsB,gBAAtB,EAAwC,MAAM;AAC5C,iBAAKC,WAAL;AACD,WAFD;AAGD;;AAED;;AAEA;;AAEA,cAAMC,qBAAN,CAA4B1D,GAA5B,EAAiC2D,qBAAjC,EAAwD;AACtD,cAAI5F,OAAO,MAAMb,OAAOc,qBAAP,CAA6B,iCAA7B,CAAjB;AACAD,eAAKE,KAAL;AACAF,eAAKI,QAAL,CAAc,oBAAd;AACA,iBAAOJ,KAAKM,WAAL,CAAiB2B,GAAjB,EAAsB2D,qBAAtB,CAAP;AACD;;AAEDC,+BAAuB;AACrB,cAAIC,qBAAJ;AACA,eAAKpS,WAAL,CAAiBuB,QAAjB,CAA0B;AACxB8Q,qCAAyB7R,IAAzB,EAA+B;AAC7B,kBAAIA,QAAQA,KAAK2B,IAAL,CAAUyI,WAAlB,IAAiCpK,KAAK2B,IAAL,CAAUyI,WAAV,CAAsBX,IAAtB,IAA8B,kBAAnE,EAAuF;AACrFmI,wCAAwB5R,KAAK2B,IAAL,CAAUyI,WAAV,CAAsB8G,IAAtB,CAA2BA,IAA3B,CAAgC/R,GAAhC,CAAoC8P,QAAQA,KAAK3G,GAAL,CAAS5D,IAArD,CAAxB;AACA1E,qBAAKiB,IAAL;AACD;AACF;AANuB,WAA1B;AAQA,iBAAO2Q,yBAAyB,EAAhC;AACD;;AAED,cAAMf,qBAAN,GAA8B;AAC5B,gBAAM9C,MAAM,MAAM,KAAK+D,gBAAL,EAAlB;AACA,cAAI/D,IAAI9O,MAAJ,IAAc,CAAlB,EAAqB;AACnB;AACD;;AAED,cAAI8S,kBAAkB,KAAKJ,oBAAL,EAAtB;AACA,cAAID,wBAAwB3D,IAAI5O,GAAJ,CAAQ8P,QAAQ8C,gBAAgBlM,QAAhB,CAAyB,KAAKmM,8BAAL,CAAoC/C,KAAKzG,EAAzC,CAAzB,CAAhB,CAA5B;AACA,gBAAMyJ,gBAAgB,MAAM,KAAKR,qBAAL,CAA2B1D,GAA3B,EAAgC2D,qBAAhC,CAA5B;;AAEA,cAAIO,cAAchT,MAAd,KAAyB,CAA7B,EAAgC;AAC9B;AACD;AACDgM,iBAAOiH,IAAP,CAAa,GAAED,cAAchT,MAAO,sBAApC;;AAEAgT,wBAAcjH,OAAd,CAAsBmH,QAAQ;AAC5B,iBAAKC,oBAAL,CAA0BD,KAAK3J,EAA/B,EAAmC9D,QAAQ,KAAK2N,iBAAL,CAAuB3N,IAAvB,CAA3C;AACA,kBAAMiF,eAAe,KAAK5H,mCAAL,CAAyC,KAAKvC,WAA9C,EAA2D,KAAKN,cAAhE,CAArB;AACA,gBAAIiO,OAAOxD,aAAavJ,MAAb,CAAoBvC,GAApB,CAAwBgE,GAAxB,CAA4BsL,IAA5B,GAAmC,CAA9C;AACA,iBAAKrO,MAAL,CAAYiJ,YAAZ,CAAyB,EAAEoF,IAAF,EAAQrF,IAAI,CAAZ,EAAzB;AACD,WALD;AAMD;;AAED,cAAMgK,gBAAN,GAAyB;AACvB,cAAIhT,SAASmM,OAAOqH,UAAP,CAAkB,KAAK3T,gBAAvB,EAAyCuB,SAAzC,EAAoD,IAApD,EAA0DkH,IAA1D,CAA+DmL,OAAOA,IAAIC,OAAJ,IAAeD,IAAIC,OAAJ,KAAgB,eAArG,CAAb;AACA,cAAIC,QAAQC,UAAU5T,OAAO6T,UAAP,CAAkBC,aAAlB,CAAgC,WAAhC,EAA6C7L,KAAvD,CAAZ;AACA,gBAAM8L,UAAiB7U,qBAAP,aAA6B,MAA7B,CAAhB;AACA,cAAI8U,OAAO,MAAMD,QAAQE,SAAR,EAAjB;;AAEA,cAAID,SAAS,mBAAb,EAAkC;AAChC7H,mBAAOiH,IAAP,CAAY,6CAAZ;AACA,mBAAO,EAAP;AACD;;AAED,cAAIc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAAJ;AACAA,cAAIC,SAAJ,GAAgBH,IAAhB;AACA,cAAI/E,MAAMiF,IAAIE,UAAJ,CAAe,CAAf,EAAkBC,OAAlB,CAA0BC,gBAA1B,CAA2C,MAA3C,EAAmDjU,GAAnD,CAAuDkU,MAAMA,GAAG7K,EAAhE,CAAV;;AAEA,gBAAM8K,YAAYR,KAAKjG,KAAL,CAAW,IAAX,CAAlB;;AAEA,gBAAM0G,kBAAkB,EAAxB;AACA,eAAK,MAAM/K,EAAX,IAAiBuF,GAAjB,EAAsB;AACpB,iBAAK,MAAMZ,IAAX,IAAmBmG,SAAnB,EAA8B;AAC5B,oBAAME,YAAYrG,KAAKjG,OAAL,CAAa,UAAUsB,EAAV,GAAe,IAA5B,CAAlB;AACA,kBAAIgL,cAAc,CAAC,CAAnB,EAAsB;AACpBD,gCAAgB7Q,IAAhB,CAAqB,EAAE8F,EAAF,EAAMmC,KAAKkI,OAAX,EAAoB1F,MAAMmG,UAAUpM,OAAV,CAAkBiG,IAAlB,CAA1B,EAAmDrF,IAAI0L,YAAY,CAAnE,EAArB;AACA;AACD;AACF;AACF;AACD,iBAAOD,eAAP;AACD;;AAEDxD,2BAAmB;AACjB,eAAKqC,oBAAL,CAA0B,qBAA1B,EAAiD5J,MAAM,KAAKiL,eAAL,CAAqBjL,GAAG1D,UAAxB,CAAvD;AACD;;AAEDkL,yBAAiB;AACf,eAAKoC,oBAAL,CAA0B,gBAA1B,EAA4C5J,MAAM,KAAKkL,aAAL,CAAmBlL,GAAG1D,UAAtB,CAAlD;AACD;;AAEDmL,yBAAiB;AACf,eAAKmC,oBAAL,CAA0B,gBAA1B,EAA4C5J,MAAM,KAAKmL,aAAL,CAAmBnL,GAAG1D,UAAtB,CAAlD;AACD;;AAED+K,wBAAgB;AACd,eAAKuC,oBAAL,CAA0B,cAA1B,EAA0C5J,MAAM,KAAKoL,YAAL,CAAkBpL,GAAG1D,UAArB,CAAhD;AACD;;AAED,cAAMsN,oBAAN,CAA2BtN,UAA3B,EAAuC+O,oBAAvC,EAA6D;AAC3D,gBAAMC,aAAa,KAAKA,UAAxB;AACA,gBAAM9R,YAAY,KAAK9C,cAAvB;;AAEA,cAAI6U,mBAAmB,EAAEjP,UAAF,EAAvB;;AAEA,cAAIkP,aAAJ;AACA,eAAKpU,UAAL,GAAkB,KAAKA,UAAL,CAAgBqU,cAAhB,CAA+B,OAAO;AACtDC,qBAAS;AACPnU,uBAASP,eAAe;AACtB,oBAAI2U,aAAa,KAAK7S,mBAAL,CAAyB9B,WAAzB,EAAsCwC,UAAUiI,KAAhD,CAAjB;AACA,oBAAImK,aAAa,KAAKrS,mCAAL,CAAyCvC,WAAzC,EAAsD,KAAKN,cAA3D,CAAjB;AACA;AACA8U,gCAAgBH,qBAAqBE,gBAArB,CAAhB;AACA,oBAAII,eAAejU,SAAnB,EAA8B;AAC5BkU,6BAAWC,gBAAX,CAA4B,MAA5B,EAAoCL,aAApC;AACD,iBAFD,MAEO,IAAI,KAAKjF,YAAL,CAAkBqF,WAAW3K,IAA7B,EAAmC0K,WAAWzQ,UAA9C,CAAJ,EAA+D;AACpEyQ,6BAAWG,WAAX,CAAuBN,aAAvB;AACD,iBAFM,MAEA;AACLI,6BAAWC,gBAAX,CAA4B,MAA5B,EAAoCL,aAApC;AACD;AACF;AAbM;AAD6C,WAAP,CAA/B,EAgBdnU,IAhBJ;;AAkBA,cAAI0U,YAAJ;AACA,eAAK/U,WAAL,CAAiBuB,QAAjB,CAA0B;AACxB8H,0BAAc7I,IAAd,EAAoB;AAClB,kBAAI,CAACuU,YAAD,IAAiBvU,KAAK2B,IAAL,CAAUoF,KAAV,IAAmBgN,iBAAiBjP,UAAzD,EAAqE;AACnEyP,+BAAevU,IAAf;AACD;AACF,aALuB;AAMxBwE,uBAAWxE,IAAX,EAAiB;AACf,kBAAIA,KAAK2B,IAAL,CAAU+C,IAAV,IAAkBqP,iBAAiBjP,UAAvC,EAAmD;AACjDyP,+BAAevU,IAAf;AACAA,qBAAKiB,IAAL;AACD;AACF;AAXuB,WAA1B;AAaA,eAAKmD,WAAL,CAAiB,CAACmQ,YAAD,CAAjB,EAAiC,IAAjC;;AAEA,eAAKC,QAAL,CAAcV,UAAd;AACA,eAAKtC,WAAL;AACD;;AAEDiC,wBAAgBgB,WAAhB,EAA6B;AAC3B,iBAAOjW,SAAS,sBAAsB,wBAAtB,GAAiD,IAA1D,EAAgE;AACrEkW,iBAAKpW,EAAEqW,aAAF,CAAgBF,WAAhB;AADgE,WAAhE,CAAP;AAGD;;AAED;AACAf,sBAAckB,YAAd,EAA4B;AAC1B,iBAAOtW,EAAEkI,WAAF,CAAc,KAAd,EAAqBlI,EAAEwG,UAAF,CAAa8P,YAAb,CAArB,EAAiD,EAAjD,EAAqDtW,EAAEuW,cAAF,CAAiB,CAACvW,EAAEwW,eAAF,CAAkBxW,EAAEyW,gBAAF,CAAmBzW,EAAE0W,cAAF,EAAnB,EAAuC1W,EAAEwG,UAAF,CAAa,sBAAb,CAAvC,CAAlB,CAAD,CAAjB,CAArD,CAAP;AACD;;AAED6O,sBAAciB,YAAd,EAA4B;AAC1B,iBAAOtW,EAAEkI,WAAF,CAAc,KAAd,EAAqBlI,EAAEwG,UAAF,CAAa8P,YAAb,CAArB,EAAiD,CAACtW,EAAEkG,UAAF,CAAa,UAAb,CAAD,CAAjD,EAA6ElG,EAAEuW,cAAF,CAAiB,CAACvW,EAAE2W,mBAAF,CAAsB3W,EAAE4W,oBAAF,CAAuB,GAAvB,EAA4B5W,EAAEyW,gBAAF,CAAmBzW,EAAE0W,cAAF,EAAnB,EAAuC1W,EAAEwG,UAAF,CAAa,sBAAb,CAAvC,CAA5B,EAA0GxG,EAAEwG,UAAF,CAAa,UAAb,CAA1G,CAAtB,CAAD,CAAjB,CAA7E,CAAP;AACD;;AAED8O,qBAAauB,SAAb,EAAwB;AACtB,iBAAO7W,EAAE8W,gBAAF,CAAmB9W,EAAEwG,UAAF,CAAaqQ,SAAb,CAAnB,EAA4C,IAA5C,EAAkD7W,EAAE+W,SAAF,CAAY,CAAC/W,EAAEkI,WAAF,CAAc,aAAd,EAA6BlI,EAAEkG,UAAF,CAAa,aAAb,CAA7B,EAA0D,EAA1D,EAA8DlG,EAAEuW,cAAF,CAAiB,EAAjB,CAA9D,CAAD,CAAZ,CAAlD,EAAsJ,EAAtJ,CAAP;AACD;;AAEDxC,0BAAkBiD,QAAlB,EAA4B;AAC1B,cAAIV,eAAeU,SAASxQ,UAA5B;AACA,cAAIyQ,aAAa,KAAKvD,8BAAL,CAAoC4C,YAApC,CAAjB;AACAU,mBAASxQ,UAAT,GAAsByQ,UAAtB;AACA,iBAAOjX,EAAEkI,WAAF,CAAc,KAAd,EAAqBlI,EAAEwG,UAAF,CAAayQ,UAAb,CAArB,EAA+C,EAA/C,EAAmDjX,EAAEuW,cAAF,CAAiB,CAACvW,EAAEwW,eAAF,CAAkBxW,EAAEkX,cAAF,CAAiBlX,EAAEyW,gBAAF,CAAmBzW,EAAE0W,cAAF,EAAnB,EAAuC1W,EAAEwG,UAAF,CAAa,KAAb,CAAvC,CAAjB,EAA8E,CAACxG,EAAEqW,aAAF,CAAgB,MAAMC,YAAtB,CAAD,CAA9E,CAAlB,CAAD,CAAjB,CAAnD,CAAP;AACD;;AAED5C,uCAA+BtN,IAA/B,EAAqC;AACnC,iBAAOA,KAAK6H,SAAL,EAAP;AACD;;AAED,cAAMkJ,YAAN,CAAmBC,WAAnB,EAAgCC,YAAhC,EAA8C;AAC5C,cAAIC,QAAQ,MAAM3K,OAAO4K,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;;AAEA3F,kBAAU1F,GAAV,EAAesL,UAAf,EAA2BC,UAA3B,EAAuC;AACrC,gBAAMlU,YAAY,KAAK9C,cAAvB;AACA,gBAAM4U,aAAa,KAAKA,UAAxB;AACA,eAAKlU,UAAL,GAAkB,KAAKA,UAAL,CAAgBqU,cAAhB,CAA+B,OAAO;AACtDC,qBAAS;AACPnU,uBAASP,eAAe;AACtB,oBAAI2W,0BAA0B,KAAKxV,QAAL,CAAcnB,WAAd,EAA2BQ,QAAQ;AAC/D,yBAAO1B,EAAE8X,mBAAF,CAAsBpW,IAAtB,KAA+BA,KAAK2B,IAAL,CAAU0U,MAAV,CAAiBtP,KAAjB,IAA0B4D,GAAhE;AACD,iBAF6B,CAA9B;AAGA,oBAAIhB,eAAe,KAAK5H,mCAAL,CAAyCvC,WAAzC,EAAsDwC,SAAtD,CAAnB;AACA,oBAAI,CAACmU,uBAAL,EAA8B;AAC5B,sBAAIG,kBAAkBhY,EAAEiY,iBAAF,CAAoB,CAACjY,EAAEkY,eAAF,CAAkBlY,EAAEwG,UAAF,CAAamR,UAAb,CAAlB,EAA4C3X,EAAEwG,UAAF,CAAamR,UAAb,CAA5C,CAAD,CAApB,EAA6F3X,EAAEqW,aAAF,CAAgBhK,GAAhB,CAA7F,CAAtB;AACAnL,8BAAYmC,IAAZ,CAAiBuP,IAAjB,CAAsBpB,OAAtB,CAA8BwG,eAA9B;AACD,iBAHD,MAGO,IAAI,CAACH,wBAAwBxU,IAAxB,CAA6B8U,UAA7B,CAAwCvI,IAAxC,CAA6CwI,QAAQA,KAAKC,QAAL,CAAcjS,IAAd,IAAsBuR,UAA3E,CAAL,EAA6F;AAClGE,0CAAwBxU,IAAxB,CAA6B8U,UAA7B,CAAwC/T,IAAxC,CAA6CpE,EAAEwG,UAAF,CAAamR,UAAb,CAA7C;AACD;AACD,oBAAI,CAACC,UAAL,EAAiB;AACfvM,+BAAaiN,WAAb,CAAyBtY,EAAEyW,gBAAF,CAAmBzW,EAAEwG,UAAF,CAAamR,UAAb,CAAnB,EAA6C3X,EAAEwG,UAAF,CAAa6E,aAAahI,IAAb,CAAkB+C,IAA/B,CAA7C,CAAzB;AACD;AACF;AAfM;AAD6C,WAAP,CAA/B,EAkBd7E,IAlBJ;AAmBA,eAAK2U,QAAL,CAAcV,UAAd;AACD;;AAED;;AAEA;AACA+C,uBAAejS,WAAf,EAA4BkS,iBAA5B,EAA+CC,gBAA/C,EAAiE;AAC/D,iBAAOnS,YAAYkC,MAAZ,CAAmBhC,cAAc;AACtC,mBAAO,KAAKkS,kBAAL,CAAwBlS,UAAxB,EAAoCgS,iBAApC,CAAP;AACD,WAFM,EAEJhQ,MAFI,CAEGhC,cAAc;AACtB,kBAAMmS,cAAcnS,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,EAAkD1E,IAAtE;AACA,mBAAO,CAAC,KAAKkX,UAAL,CAAgBD,WAAhB,EAA6BF,gBAA7B,CAAR;AACD,WALM,EAKJ5X,GALI,CAKA2F,cAAc;AACnB,mBAAO,KAAKI,mCAAL,CAAyCJ,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAzC,EAA4F/C,IAAnG;AACD,WAPM,CAAP;AAQD;;AAEDwV,sBAAchE,OAAd,EAAuB;AACrB,cAAIiE,WAAW,KAAf;AACAjE,kBAAQnI,OAAR,CAAgB1G,aAAa;AAC3B,gBAAIhG,EAAE+Y,iBAAF,CAAoB/S,UAAU3C,IAA9B,CAAJ,EAAyC;AACvCyV,yBAAW,IAAX;AACD,aAFD,MAEO;AACL9S,wBAAUvD,QAAV,CAAmB;AACjBuW,gCAAgBtX,IAAhB,EAAsB;AACpBoX,6BAAW,IAAX;AACApX,uBAAKiB,IAAL;AACD;AAJgB,eAAnB;AAMD;AACF,WAXD;;AAaA,iBAAOmW,QAAP;AACD;;AAEDG,sBAAcpE,OAAd,EAAuB;AACrB,cAAIqE,UAAU,KAAd;AACArE,kBAAQnI,OAAR,CAAgB1G,aAAa;AAC3BA,sBAAUvD,QAAV,CAAmB;AACjB0W,6BAAezX,IAAf,EAAqB;AACnBwX,0BAAU,IAAV;AACAxX,qBAAKiB,IAAL;AACD;AAJgB,aAAnB;AAMD,WAPD;;AASA,iBAAO,CAACuW,OAAR;AACD;;AAEDR,2BAAmBlS,UAAnB,EAA+BgS,iBAA/B,EAAkD;AAChD,iBAAOhS,WAAWC,KAAX,CAAiBC,UAAjB,CAA4BF,WAAWnD,IAAX,CAAgB+C,IAA5C,KAAqD,CAACoS,kBAAkBpT,UAAlB,CAA6BqB,KAA7B,CAAmCC,UAAnC,CAA8CF,WAAWnD,IAAX,CAAgB+C,IAA9D,CAA7D;AACD;;AAEDgT,yBAAiB9S,WAAjB,EAA8BkS,iBAA9B,EAAiDC,gBAAjD,EAAmE;AACjE,gBAAMnN,WAAW,CAAC,GAAG,IAAInE,GAAJ,CAAQb,YAAYkC,MAAZ,CAAmBhC,cAAc;AAC5D,mBAAOA,WAAWC,KAAX,CAAiBC,UAAjB,CAA4BF,WAAWnD,IAAX,CAAgB+C,IAA5C,KAAqD,CAACoS,kBAAkBpT,UAAlB,CAA6BqB,KAA7B,CAAmCC,UAAnC,CAA8CF,WAAWnD,IAAX,CAAgB+C,IAA9D,CAA7D;AACD,WAF4B,EAE1BvF,GAF0B,CAEtB2F,cAAc;AACnB,mBAAOA,WAAWC,KAAX,CAAiBE,UAAjB,CAA4BH,WAAWnD,IAAX,CAAgB+C,IAA5C,CAAP;AACD,WAJ4B,CAAR,CAAJ,CAAjB;;AAMA,iBAAOkF,SAAS9C,MAAT,CAAgB3B,WAAW;AAChC,kBAAMwS,yBAAyB,KAAKT,UAAL,CAAgB/R,QAAQnF,IAAxB,EAA8B+W,gBAA9B,CAA/B;AACA,kBAAMa,+BAA+BzS,QAAQQ,kBAAR,CAA2BuI,IAA3B,CAAgC2J,qBAAqB,KAAKX,UAAL,CAAgBW,iBAAhB,EAAmCd,gBAAnC,CAArD,CAArC;AACA,kBAAMe,4BAA4B3S,QAAQO,cAAR,CAAuBwI,IAAvB,CAA4B1B,aAAa,CAAC,KAAK0K,UAAL,CAAgB1K,SAAhB,EAA2BuK,gBAA3B,CAA1C,CAAlC;;AAEA,mBAAO,KAAKgB,iBAAL,CAAuBJ,sBAAvB,EAA+CC,4BAA/C,EAA6EE,yBAA7E,CAAP;AACD,WANM,EAMJ3Y,GANI,CAMAgG,WAAW;AAChB,kBAAM6S,oCAAoC7S,QAAQQ,kBAAR,CAA2BuI,IAA3B,CAAgC2J,qBAAqB,CAAC,KAAKX,UAAL,CAAgBW,iBAAhB,EAAmCd,gBAAnC,CAAtD,CAA1C;AACA,mBAAO,EAAEpV,MAAM,KAAKuD,mCAAL,CAAyCC,OAAzC,EAAkDxD,IAA1D,EAAgEsW,yBAAyB,KAAKf,UAAL,CAAgB/R,QAAQnF,IAAxB,EAA8B+W,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,qBAAa/E,OAAb,EAAsBgF,SAAtB,EAAiCC,YAAjC,EAA+CrT,KAA/C,EAAsDsT,oBAAtD,EAA4ElB,aAA5E,EAA2FmB,cAA3F,EAA2G;AACzG,cAAID,wBAAwBD,aAAanZ,MAAb,GAAsB,CAAlD,EAAqD;AACnDgM,mBAAOiH,IAAP,CAAY,mGAAZ;AACD;AACD,cAAI4C,eAAJ;AACAsD,uBAAapN,OAAb,CAAqBuN,eAAeA,YAAYC,gBAAZ,GAA+BD,YAAYN,uBAAZ,GAAsCM,YAAY5W,IAAlD,GAAyDrD,EAAEwG,UAAF,CAAayT,YAAY5W,IAAZ,CAAiB+C,IAAjB,GAAwB,SAArC,CAA5H;AACA,cAAI0T,aAAanZ,MAAb,IAAuB,CAA3B,EAA8B;AAC5B6V,8BAAkBxW,EAAEwW,eAAF,CAAkBsD,aAAa,CAAb,EAAgBzW,IAAlC,CAAlB;AACD,WAFD,MAEO,IAAIyW,aAAanZ,MAAb,GAAsB,CAA1B,EAA6B;AAClC6V,8BAAkBxW,EAAEwW,eAAF,CAAkBxW,EAAEma,gBAAF,CAAmBL,aAAajZ,GAAb,CAAiBoI,KAAKjJ,EAAEoa,cAAF,CAAiBnR,EAAEiR,gBAAnB,EAAqCjR,EAAE5F,IAAvC,EAA6C,KAA7C,EAAoD,IAApD,CAAtB,CAAnB,CAAlB,CAAlB;AACD;;AAED,cAAIgX,gBAAgBxF,QAAQhU,GAAR,CAAYyZ,KAAK;AACnC;AACAA,cAAEjX,IAAF,CAAO9D,GAAP,GAAa,IAAb;AACA+a,cAAEjX,IAAF,CAAOsI,KAAP,GAAe,IAAf;AACA2O,cAAEjX,IAAF,CAAOE,GAAP,GAAa,IAAb;AACA,mBAAO+W,EAAEjX,IAAT;AACD,WANmB,CAApB;AAOA,cAAImT,eAAJ,EAAqB;AACnB6D,0BAAcjW,IAAd,CAAmBoS,eAAnB;AACD,WAFD,MAEO,IAAIuD,oBAAJ,EAA0B;AAC/BM,4BAAgB,CAACra,EAAEwW,eAAF,CAAkB3B,QAAQ,CAAR,EAAWxR,IAA7B,CAAD,CAAhB;AACD;AACD,gBAAMkX,YAAYva,EAAEkI,WAAF,CAAc,QAAd,EAAwBlI,EAAEwG,UAAF,CAAa,uCAAb,CAAxB,EAA+EqT,SAA/E,EAA0F7Z,EAAEuW,cAAF,CAAiB8D,aAAjB,CAA1F,CAAlB;AACAE,oBAAUC,KAAV,GAAkB3B,aAAlB;AACA0B,oBAAUE,MAAV,GAAmBT,cAAnB;AACAvT,gBAAMuP,WAAN,CAAkBuE,SAAlB;AACA,eAAK,IAAItR,IAAI,CAAb,EAAgBA,IAAI4L,QAAQlU,MAAR,GAAiB,CAArC,EAAwCsI,GAAxC,EAA6C;AAC3C4L,oBAAQ5L,CAAR,EAAWqI,MAAX;AACD;AACD,cAAIoJ,UAAJ;AACA,cAAIxD,iBAAiBlX,EAAEkX,cAAF,CAAiBlX,EAAEwG,UAAF,CAAa,4CAAb,CAAjB,EAA6EqT,SAA7E,CAArB;AACA,cAAIhB,aAAJ,EAAmB;AACjBlM,mBAAOiH,IAAP,CAAY,8DAAZ;AACAsD,6BAAiBlX,EAAE2a,eAAF,CAAkBzD,cAAlB,CAAjB;AACD;AACD,cAAI4C,aAAanZ,MAAb,IAAuB,CAA3B,EAA8B;AAC5B,gBAAImZ,aAAa,CAAb,EAAgBH,uBAApB,EAA6C;AAC3C,oBAAMiB,eAAed,aAAa,CAAb,EAAgBJ,iCAAhB,GAAoD,KAApD,GAA4D,OAAjF;AACAgB,2BAAa,CAAC1a,EAAE6a,mBAAF,CAAsBD,YAAtB,EAAoC,CAAC5a,EAAE8a,kBAAF,CAAqBhB,aAAa,CAAb,EAAgBzW,IAArC,EAA2C6T,cAA3C,CAAD,CAApC,CAAD,CAAb;AACD,aAHD,MAGO;AACLwD,2BAAa,CAAC1a,EAAE2W,mBAAF,CAAsB3W,EAAE4W,oBAAF,CAAuB,GAAvB,EAA4BkD,aAAa,CAAb,EAAgBzW,IAA5C,EAAkD6T,cAAlD,CAAtB,CAAD,CAAb;AACD;AACF,WAPD,MAOO,IAAI4C,aAAanZ,MAAb,GAAsB,CAA1B,EAA6B;AAClC,kBAAMoa,gBAAgB/a,EAAE+a,aAAF,CAAgBjB,aAAajZ,GAAb,CAAiBoI,KAAKjJ,EAAEoa,cAAF,CAAiBnR,EAAEiR,gBAAnB,EAAqCjR,EAAEiR,gBAAvC,EAAyD,KAAzD,EAAgE,IAAhE,CAAtB,CAAhB,CAAtB;AACAQ,yBAAa,CAAC1a,EAAE6a,mBAAF,CAAsB,OAAtB,EAA+B,CAAC7a,EAAE8a,kBAAF,CAAqBC,aAArB,EAAoC7D,cAApC,CAAD,CAA/B,CAAD,CAAb;AACA4C,yBAAapN,OAAb,CAAqB8J,mBAAmB;AACtC,kBAAIA,gBAAgBnT,IAAhB,IAAwBmT,gBAAgB0D,gBAA5C,EAA8D;AAC5DQ,2BAAWtW,IAAX,CAAgBpE,EAAE2W,mBAAF,CAAsB3W,EAAE4W,oBAAF,CAAuB,GAAvB,EAA4BJ,gBAAgBnT,IAA5C,EAAkDmT,gBAAgB0D,gBAAlE,CAAtB,CAAhB;AACD;AACF,aAJD;AAKD,WARM,MAQA;AACLQ,yBAAa,CAACxD,cAAD,CAAb;AACD;AACDrC,kBAAQA,QAAQlU,MAAR,GAAiB,CAAzB,EAA4Bqa,mBAA5B,CAAgDN,UAAhD;AACD;;AAED,cAAMvI,aAAN,GAAsB;AACpB,gBAAMqD,aAAa,KAAKA,UAAxB;AACA,gBAAMyF,cAAc,KAAK3Z,UAAL,CAAgBqU,cAAhB,CAA+B,CAAC,EAAE1V,OAAOD,CAAT,EAAYE,QAAZ,EAAD,MAA6B;AAC9E0V,qBAAS;AACPnU,uBAASP,eAAe;AACtB,sBAAM;AACJgD,+BADI;AAEJ6V,sCAFI;AAGJtB;AAHI,oBAIF,KAAKrG,sBAAL,CAA4BlR,WAA5B,CAJJ;;AAMA,sBAAMoF,cAAcpC,cAAcrD,GAAd,CAAkB,KAAKwF,iBAAvB,EAA0C/B,IAA1C,EAApB;AACA,oBAAIkU,oBAAoBtU,cAAc,CAAd,EAAiB4E,IAAjB,CAAsBhH,UAAU;AACtD,yBAAOA,OAAOuB,IAAP,CAAY8H,IAAZ,IAAoB,aAA3B;AACD,iBAFuB,CAAxB;AAGA,oBAAI6O,iBAAiB,KAAKf,aAAL,CAAmB/U,aAAnB,CAArB;AACA,oBAAI,CAACsU,iBAAL,EAAwB;AACtBA,sCAAoBtU,cAAcA,cAAcvD,MAAd,GAAuB,CAArC,CAApB;AACD,iBAFD,MAEO;AACLqZ,mCAAiBxB,kBAAkBnV,IAAlB,CAAuBoX,MAAxC;AACD;AACD,sBAAM5B,gBAAgB,KAAKA,aAAL,CAAmB3U,aAAnB,CAAtB;AACA,sBAAMgX,aAAa,KAAK3C,cAAL,CAAoBjS,WAApB,EAAiCkS,iBAAjC,EAAoDC,gBAApD,CAAnB;AACA,sBAAMqB,eAAe,KAAKV,gBAAL,CAAsB9S,WAAtB,EAAmCkS,iBAAnC,EAAsDC,gBAAtD,CAArB;AACA,qBAAKmB,YAAL,CAAkB1V,aAAlB,EAAiC,CAAC,GAAG,IAAIiD,GAAJ,CAAQ+T,UAAR,CAAJ,CAAjC,EAA2DpB,YAA3D,EAAyEtB,iBAAzE,EAA4FuB,oBAA5F,EAAkHlB,aAAlH,EAAiImB,cAAjI;AACD;AAtBM;AADqE,WAA7B,CAA/B,CAApB;AA0BA,eAAK1Y,UAAL,GAAkB2Z,YAAY1Z,IAA9B;AACA,eAAK2U,QAAL,CAAcV,UAAd;AACA,gBAAM2F,gBAAgB,EAAtB;AACA,eAAKja,WAAL,CAAiBuB,QAAjB,CAA0B;AACxByD,uBAAWxE,IAAX,EAAiB;AACf,kBAAIA,KAAK2B,IAAL,CAAU+C,IAAV,IAAkB,uCAAtB,EAA+D;AAC7D+U,8BAAc/W,IAAd,CAAmB1C,IAAnB;AACD;AACF;AALuB,WAA1B;AAOA,eAAKoE,WAAL,CAAiBqV,aAAjB;AACD;;AAED;;AAEA/I,+BAAuBlR,WAAvB,EAAoCka,SAAS,KAA7C,EAAoD;AAClD,cAAIlX,gBAAgB,KAAKK,qBAAL,CAA2BrD,WAA3B,CAApB;AACA,cAAI6Y,uBAAuB,KAA3B;;AAEA,cAAI7V,cAAcvD,MAAd,IAAwB,CAA5B,EAA+B;AAC7B,gBAAI0a,cAAc,KAAKzW,sBAAL,CAA4B1D,WAA5B,CAAlB;AACA,gBAAIma,YAAY1a,MAAZ,GAAqB,CAAzB,EAA4B;AAC1B,kBAAI,CAACya,MAAL,EAAazO,OAAOiH,IAAP,CAAY,2FAAZ;AACb;AACD,aAHD,MAGO,IAAIyH,YAAY1a,MAAZ,IAAsB,CAA1B,EAA6B;AAClC,kBAAI,CAACya,MAAL,EAAazO,OAAOiH,IAAP,CAAY,gDAAZ;AACb;AACD,aAHM,MAGA;AACL1P,8BAAgBmX,WAAhB;AACAtB,qCAAuB,IAAvB;AACD;AACF;;AAED,gBAAMtB,mBAAmBvU,cAAcrD,GAAd,CAAkBa,QAAQ;AACjD,mBAAOlC,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAAP;AACD,WAFwB,CAAzB;AAGA,iBAAO;AACL2E,yBADK;AAEL6V,gCAFK;AAGLtB;AAHK,WAAP;AAKD;;AAED,cAAMxG,kCAAN,GAA2C;AACzC,gBAAMvO,YAAY,KAAK9C,cAAvB;AACA,cAAI0a,OAAO,KAAX;;AAEA,gBAAM9F,aAAa,KAAKA,UAAxB;;AAEA,cAAI+F,yBAAJ;AACA,gBAAMC,MAAM,KAAKla,UAAL,CAAgBqU,cAAhB,CAA+B,CAAC,EAAE1V,OAAOD,CAAT,EAAD,MAAmB;AAC5D4V,qBAAS;AACP7Q,0BAAYrD,QAAQ;AAClB,oBAAI,CAAC4Z,IAAL,EAAW;AACT,wBAAMG,iBAAiB,KAAKxX,qBAAL,CAA2BvC,IAA3B,EAAiCgC,SAAjC,CAAvB;AACA,sBAAI+X,cAAJ,EAAoB;AAClBF,gDAA4B7Z,KAAKga,eAAL,EAA5B;;AAEAha,yBAAKoH,IAAL,CAAUwR,KAAK;AACb,4BAAMlV,aAAakV,EAAElV,UAArB;AACA,0BAAI,CAACA,UAAL,EAAiB;AACf,+BAAO,KAAP;AACD;;AAED,+BAASuW,WAAT,CAAqB/I,IAArB,EAA2B;AACzB,4BAAI,CAACA,KAAKvP,IAAV,EAAgB,OAAO,KAAP;;AAEhB,4BAAIuP,KAAKlO,gBAAL,EAAJ,EAA6B;AAC3B,iCAAO,KAAP;AACD;;AAED,8BAAMkX,aAAa,EAAnB;AACA,4BAAIhJ,KAAKnO,WAAL,EAAJ,EAAwB;AACtBmX,qCAAWxX,IAAX,CAAgBwO,KAAKvP,IAArB;AACA,gCAAMwY,YAAY7b,EAAEuW,cAAF,CAAiBqF,UAAjB,CAAlB;AACAhJ,+BAAK0F,WAAL,CAAiBuD,SAAjB;AACA,iCAAO,IAAP;AACD,yBALD,MAKO,IAAIjJ,KAAKxN,UAAL,CAAgB0W,yBAAhB,MAA+ClJ,KAAK/N,YAAL,EAAnD,EAAwE;AAC7E+W,qCAAWxX,IAAX,CAAgBpE,EAAEwW,eAAF,CAAkB5D,KAAKvP,IAAvB,CAAhB;AACA,gCAAMwY,YAAY7b,EAAEuW,cAAF,CAAiBqF,UAAjB,CAAlB;AACAhJ,+BAAK0F,WAAL,CAAiBuD,SAAjB;AACA,iCAAO,IAAP;AACD,yBALM,MAKA;AACL,gCAAM,IAAIE,KAAJ,CAAU,yCAAV,CAAN;AACD;AACF;;AAED,4BAAMC,iBAAiBta,KAAKga,eAAL,EAAvB;AACA,4BAAMO,gBAAgB3B,EAAEoB,eAAF,EAAtB;AACA,0BAAIpB,EAAE4B,SAAF,KAAgB,MAAhB,KAA2B9W,WAAW+W,KAAX,MAAsB/W,WAAWgX,OAAX,EAAjD,CAAJ,EAA4E;AAC1E,8BAAMC,eAAeV,YAAYrB,CAAZ,CAArB;AACA,4BAAI+B,YAAJ,EAAkB;AAChBd,sDAA4BU,gBAAgB,UAAhB,GAA6BD,eAAenK,OAAf,CAAuBoK,aAAvB,EAAsC,EAAtC,CAAzD;AACD;AACD,+BAAO,IAAP;AACD;AACD,0BAAI3B,EAAE4B,SAAF,KAAgB,MAAhB,IAA0B9W,WAAWwS,UAAX,EAA9B,EAAuD;AACrD,8BAAMyE,eAAeV,YAAYrB,CAAZ,CAArB;AACA,4BAAI+B,YAAJ,EAAkB;AAChBd,sDAA4BU,gBAAgB,mBAAhB,GAAsCD,eAAenK,OAAf,CAAuBoK,aAAvB,EAAsC,EAAtC,CAAlE;AACD;AACD,+BAAO,IAAP;AACD;AACD,0BAAI,CAAC3B,EAAE4B,SAAF,KAAgB,YAAhB,IAAgC5B,EAAE4B,SAAF,KAAgB,WAAjD,KAAiE9W,WAAWkX,aAAX,EAArE,EAAiG;AAC/F,8BAAMD,eAAeV,YAAYrB,CAAZ,CAArB;AACA,4BAAI+B,YAAJ,EAAkB;AAChBd,sDAA4BU,gBAAgB,UAAhB,GAA6BD,eAAenK,OAAf,CAAuBoK,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;AAC9B5O,mBAAOiH,IAAP,CAAY,iCAAZ;AACA;AACD;;AAED,gBAAM2I,wBAAwB,EAA9B;AACA,gBAAMC,kBAAkBhB,IAAIja,IAAJ,CAASoU,cAAT,CAAwB,CAAC,EAAE1V,OAAOD,CAAT,EAAYE,QAAZ,EAAD,MAA6B;AAC3E0V,qBAAS;AACPnU,uBAASP,eAAe;AACtB,sBAAMQ,OAAO,KAAK+a,yBAAL,CAA+Bvb,WAA/B,EAA4Cqa,yBAA5C,CAAb;AACA,oBAAI9S,QAAQ,EAAZ;AACA/G,qBAAKe,QAAL,CAAc;AACZyD,6BAAWoU,CAAX,EAAc;AACZ7R,6BAAS,MAAM6R,EAAEjX,IAAF,CAAO+C,IAAtB;AACD;AAHW,iBAAd;AAKA,oBAAIqC,MAAM9H,MAAN,GAAe,CAAnB,EAAsB;AACpB;AACA8H,0BAAQA,MAAMwF,SAAN,EAAR;AACD,iBAHD,MAGO;AACLxF,0BAAQ/G,KAAK+E,KAAL,CAAWiW,qBAAX,CAAiC,MAAjC,EAAyCtW,IAAjD;AACD;AACD,sBAAMI,aAAaxG,EAAEkG,UAAF,CAAauC,KAAb,CAAnB;AACA,sBAAMkU,OAAOzc,SAAS,kBAAT,EAA6B;AACxC0c,sBAAIpW,UADoC;AAExCqW,wBAAMnb,KAAK2B;AAF6B,iBAA7B,CAAb;;AAKA,oBAAIyZ,WAAW9c,EAAEkG,UAAF,CAAauC,KAAb,CAAf;;AAEA/G,qBAAK4W,WAAL,CAAiBwE,QAAjB;AACA,sBAAMC,sBAAsBrb,KAAKsb,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,sCAAsBnY,IAAtB,CAA2B8Y,8BAA8BxB,eAA9B,EAA3B;AACAa,sCAAsBnY,IAAtB,CAA2B1C,KAAKga,eAAL,EAA3B;AACD;AA7BM;AADkE,WAA7B,CAAxB,CAAxB;AAiCA,eAAKpa,UAAL,GAAkBkb,gBAAgBjb,IAAlC;;AAEA,gBAAM4Z,gBAAgB,KAAKiC,qBAAL,CAA2Bb,qBAA3B,CAAtB;;AAEA,eAAKzW,WAAL,CAAiBqV,aAAjB;AACA,eAAKjI,WAAL;AACA,eAAKgD,QAAL,CAAcV,UAAd;AACD;;AAED,cAAMtD,kCAAN,GAA2C;AACzC,gBAAMxO,YAAY,KAAK9C,cAAvB;AACA,cAAI0a,OAAO,KAAX;;AAEA,gBAAM9F,aAAa,KAAKA,UAAxB;;AAEA,cAAI+F,yBAAJ;AACA,gBAAMC,MAAM,KAAKla,UAAL,CAAgBqU,cAAhB,CAA+B,OAAO;AAChDC,qBAAS;AACP7Q,0BAAYrD,QAAQ;AAClB,oBAAI,CAAC4Z,IAAL,EAAW;AACT,wBAAMG,iBAAiB,KAAKxX,qBAAL,CAA2BvC,IAA3B,EAAiCgC,SAAjC,CAAvB;AACA,sBAAI+X,cAAJ,EAAoB;AAClBF,gDAA4B7Z,KAAKga,eAAL,EAA5B;AACAJ,2BAAO,IAAP;AACD;AACF;AACF;AATM;AADuC,WAAP,CAA/B,CAAZ;;AAcA,cAAI,CAACC,yBAAL,EAAgC;AAC9B5O,mBAAOiH,IAAP,CAAY,gCAAZ;AACA;AACD;;AAED,gBAAM2I,wBAAwB,EAA9B;AACA,gBAAMC,kBAAkBhB,IAAIja,IAAJ,CAASoU,cAAT,CAAwB,CAAC,EAAEzV,QAAF,EAAD,MAAmB;AACjE0V,qBAAS;AACPnU,uBAASP,eAAe;AACtB,sBAAMQ,OAAO,KAAK+a,yBAAL,CAA+Bvb,WAA/B,EAA4Cqa,yBAA5C,CAAb;AACA,sBAAM8B,KAAKnd,SAAS,mBAAT,EAA8B;AACvCod,wBAAM5b,KAAK2B;AAD4B,iBAA9B,EAERka,UAFH;;AAIA7b,qBAAK4W,WAAL,CAAiB+E,EAAjB;;AAEAd,sCAAsBnY,IAAtB,CAA2B1C,KAAKga,eAAL,EAA3B;AACD;AAVM;AADwD,WAAnB,CAAxB,CAAxB;AAcA,eAAKpa,UAAL,GAAkBkb,gBAAgBjb,IAAlC;;AAEA,gBAAM4Z,gBAAgB,KAAKiC,qBAAL,CAA2Bb,qBAA3B,CAAtB;;AAEA,eAAKzW,WAAL,CAAiBqV,aAAjB;AACA,eAAKjI,WAAL;AACA,eAAKgD,QAAL,CAAcV,UAAd;AACD;;AAED;;AAEA,YAAIlU,UAAJ,GAAiB;AACf,iBAAO,KAAKjB,gBAAL,CAAsBoI,KAA7B;AACD;AACD,YAAInH,UAAJ,CAAe+M,IAAf,EAAqB;AACnB,eAAKhO,gBAAL,CAAsBoI,KAAtB,GAA8B4F,IAA9B;AACA,eAAK9N,WAAL;AACA,iBAAO,KAAKF,gBAAL,CAAsBoI,KAA7B;AACD;;AAEDyK,sBAAc;AACZ,eAAK7S,gBAAL,CAAsBqN,KAAtB;AACD;;AAED,YAAI8H,UAAJ,GAAiB;AACf,iBAAO,KAAKlV,UAAL,CAAgBkd,aAAhB,EAAP;AACD;AACDtH,iBAASV,UAAT,EAAqB;AACnB,eAAKlV,UAAL,CAAgBqJ,cAAhB,CAA+B;AAC7BmJ,kBAAM0C,WAAW1C,IADY;AAE7B2K,iBAAKjI,WAAWiI,GAFa;AAG7BC,mBAAOlI,WAAW1C,IAAX,GAAkB0C,WAAWmI,KAHP;AAI7B3K,oBAAQwC,WAAWiI,GAAX,GAAiBjI,WAAWoI;AAJP,WAA/B,EAKG,GALH;AAMD;;AAED;;AAEAhF,mBAAWlX,IAAX,EAAiBmc,aAAa,IAA9B,EAAoC;AAClC,cAAI,CAACA,UAAL,EAAiB;AACfA,yBAAa,KAAKpd,eAAlB;AACD;AACD,gBAAMqd,YAAYte,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAAlB;AACA,eAAK,MAAMmE,SAAX,IAAwBma,UAAxB,EAAoC;AAClC,gBAAIna,UAAUG,aAAV,CAAwBia,SAAxB,CAAJ,EAAwC;AACtC,qBAAO,IAAP;AACD;AACF;AACD,iBAAO,KAAP;AACD;;AAED7Z,8BAAsBvC,IAAtB,EAA4BgC,SAA5B,EAAuC;AACrC,iBAAOA,UAAUwB,OAAV,CAAkB1F,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,CAAlB,CAAP;AACD;;AAEDkd,kCAA0Bvb,WAA1B,EAAuC6c,QAAvC,EAAiD;AAC/C,cAAIrc,OAAOR,WAAX;AACA,gBAAM8c,MAAM,iCAAZ;AACA,cAAIC,MAAJ;AACA,iBAAO,CAACA,SAASD,IAAIE,IAAJ,CAASH,QAAT,CAAV,MAAkC,IAAzC,EAA+C;AAC7C,gBAAII,OAAOF,OAAO,CAAP,CAAX;AACA,gBAAIE,KAAKC,UAAL,CAAgB,GAAhB,CAAJ,EAA0B;AACxBD,qBAAOA,KAAKtM,OAAL,CAAa,GAAb,EAAkB,EAAlB,CAAP;AACAnQ,qBAAOA,KAAKyb,GAAL,CAASgB,IAAT,CAAP;AACD,aAHD,MAGO;AACLA,qBAAOA,KAAKtM,OAAL,CAAa,SAAb,EAAwB,EAAxB,CAAP;AACAsM,qBAAOE,SAASF,IAAT,CAAP;AACAzc,qBAAOA,KAAKyc,IAAL,CAAP;AACD;AACF;;AAED,iBAAOzc,IAAP;AACD;;AAED0b,8BAAsBkB,aAAtB,EAAqC;AACnC,gBAAMxU,QAAQ,EAAd;;AAEA,eAAKxI,UAAL,CAAgBE,aAAhB,CAA8B;AAC5BC,qBAASC,QAAQ;AACf4c,4BAAc5R,OAAd,CAAsBqR,YAAY;AAChCjU,sBAAM1F,IAAN,CAAW,KAAKqY,yBAAL,CAA+B/a,IAA/B,EAAqCqc,QAArC,CAAX;AACD,eAFD;AAGD;AAL2B,WAA9B;;AAQA,iBAAOjU,KAAP;AACD;;AAED,cAAMmC,uBAAN,CAA8BgL,UAA9B,EAA0C;AACxC,cAAIvO,QAAQ,MAAM7I,UAAU2P,OAAV,EAAlB;;AAEA;AACA,cAAI+O,kBAAkB,MAAM7V,MAAMgH,EAAN,CAASU,OAAT,CAAiB5H,MAAjB,CAAwB4D,MAAM;AACxD,mBAAOA,GAAGoS,OAAH,CAAW5O,IAAX,CAAgB6O,MAAMA,GAAGrY,IAAH,IAAW6Q,UAAjC,CAAP;AACD,WAF2B,EAEzBpH,OAFyB,EAA5B;;AAIA;AACA,cAAI6O,kBAAkB,MAAMhW,MAAMgH,EAAN,CAASiP,OAAT,CAAiBC,KAAjB,CAAuB,KAAvB,EAA8BC,KAA9B,CAAoCN,gBAAgB1d,GAAhB,CAAoBuL,MAAMA,GAAGC,GAA7B,CAApC,EAAuEwD,OAAvE,EAA5B;;AAEA;AACA,cAAIiP,YAAYP,gBAAgB/V,MAAhB,CAAuB4D,MAAM;AAC3C,mBAAOsS,gBAAgB9O,IAAhB,CAAqBmP,KAAKA,EAAE1S,GAAF,IAASD,GAAGC,GAAZ,IAAmB0S,EAAE3O,OAAF,CAAUR,IAAV,CAAeoP,OAAOA,OAAO5S,GAAGhG,IAAhC,CAA7C,CAAP;AACD,WAFe,CAAhB;AAGA,iBAAO0Y,UAAUtW,MAAV,CAAiBuM,MAAMA,GAAG1I,GAAH,CAAO7B,KAAP,CAAasH,UAAb,CAAvB,CAAP,CAfwC,CAeiB;AAC1D;;AAED,cAAMvF,qBAAN,CAA4B0K,UAA5B,EAAwC;AACtC,cAAIvO,QAAQ,MAAM7I,UAAU2P,OAAV,EAAlB;AACA,cAAIsP,YAAY,MAAMpW,MAAMgH,EAAN,CAASiP,OAAT,CAAiBnW,MAAjB,CAAwByW,OAAO;AACnD,mBAAOA,IAAI9O,SAAJ,CAAcP,IAAd,CAAmB6O,MAAMA,MAAMxH,UAA/B,CAAP;AACD,WAFqB,EAEnBpH,OAFmB,EAAtB;AAGA,iBAAOiP,UAAUje,GAAV,CAActB,OAAOA,IAAI8M,GAAzB,EAA8B7D,MAA9B,CAAqC6D,OAAOA,IAAI7B,KAAJ,CAAUsH,UAAV,CAA5C,CAAP;AACD;;AAED;;AAEA/P,4BAAoB;AAClB,gBAAMmd,QAAQ,KAAKhe,WAAnB;AACA,cAAI,CAACge,KAAL,EAAY;AACV;AACD;AACD,gBAAMC,MAAM,KAAK3e,MAAL,CAAY4e,WAAZ,EAAZ;AACAD,cAAIzS,OAAJ,CAAY2S,UAAU;AACpB,gBAAIA,OAAOlU,IAAP,KAAgB,UAApB,EAAgC;AAC9BkU,qBAAOC,KAAP;AACD;AACF,WAJD;AAKA,gBAAMC,gBAAgB,KAAKnV,gBAAL,CAAsB8U,KAAtB,CAAtB;AACAK,wBAAc7S,OAAd,CAAsBhL,QAAQ;AAC5B,kBAAMqc,WAAW,EAAElP,MAAMnN,KAAK2B,IAAL,CAAU9D,GAAV,CAAcgE,GAAd,CAAkBsL,IAAlB,GAAyB,CAAjC,EAAoCrF,IAAI9H,KAAK2B,IAAL,CAAU9D,GAAV,CAAcgE,GAAd,CAAkBwM,MAA1D,EAAjB;AACA,gBAAIyP,4BAAS7M,SAAS8M,aAAT,CAAuB,OAAvB,CAAT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,cAAJ;AACAD,mBAAOrU,IAAP,GAAc,OAAd;AACAqU,mBAAO/W,KAAP,GAAe/G,KAAK2B,IAAL,CAAUoF,KAAzB;AACA+W,mBAAO5B,MAAP,GAAgB,IAAhB;AACA4B,mBAAO7B,KAAP,GAAe,IAAf;AACA,kBAAM+B,WAAW,KAAKlf,MAAL,CAAYmf,WAAZ,CAAwB5B,QAAxB,EAAkCyB,MAAlC,CAAjB;AACAA,mBAAOvM,gBAAP,CAAwB,QAAxB,EAAkC2M,SAAS;AACzC,oBAAMC,kBAAkBH,SAAS5W,IAAT,EAAxB;AACA,mBAAKgX,WAAL,CAAiBD,eAAjB,EAAkCD,MAAMG,MAAN,CAAatX,KAA/C;AACD,aAHD;AAID,WAZD;AAaD;;AAEDqX,oBAAYD,eAAZ,EAA6BG,KAA7B,EAAoC;AAClC,cAAIjC,WAAW,EAAEhd,QAAQ8e,eAAV,EAA2B5e,MAAM4e,eAAjC,EAAf;AACA,gBAAMrK,aAAa,KAAKA,UAAxB;AACA,eAAKlU,UAAL,GAAkB,KAAKA,UAAL,CAAgBqU,cAAhB,CAA+B,OAAO;AACtDC,qBAAS;AACPnU,uBAASP,eAAe;AACtB,sBAAMQ,OAAO,KAAK+B,mCAAL,CAAyCvC,WAAzC,EAAsD1B,MAAMue,QAAN,CAAtD,CAAb,CADsB,CAC+D;AACrF,oBAAI/d,EAAEuJ,eAAF,CAAkB7H,KAAK2B,IAAvB,CAAJ,EAAkC;AAChC3B,uBAAK2B,IAAL,CAAUoF,KAAV,GAAkBuX,KAAlB;AACD;AACF;AANM;AAD6C,WAAP,CAA/B,EASdze,IATJ;AAUA,eAAK2U,QAAL,CAAcV,UAAd;AACA,eAAKzT,iBAAL;AACD;;AAED;;AAEAke,yBAAiBlC,QAAjB,EAA2B;AACzB,cAAImC,SAAJ;AACF,eAAKhf,WAAL,CAAiBuB,QAAjB,CAA0B;AACzB0d,2BAAeze,IAAf,EAAqB;AAChB,kBAAI,CAAClC,MAAMkC,KAAK2B,IAAL,CAAU9D,GAAhB,EAAqB6gB,QAArB,CAA8BrC,QAA9B,CAAL,EAA8C;AAC5Crc,qBAAK2C,IAAL;AACD,eAFD,MAEO,IAAIgc,QAAQ3e,IAAR,CAAJ,EAAmB;AACxBwe,4BAAYxe,IAAZ;AACAA,qBAAKiB,IAAL;AACL;AACD;AARwB,WAA1B;AAUE,iBAAOud,SAAP;AACD;;AAED,YAAII,6BAAJ,GAAoC;AAClC,iBAAO,KAAKpf,WAAL,CAAiBmC,IAAjB,CAAsBkd,UAAtB,CAAiC3Q,IAAjC,CAAsCvM,QAAQ;AACnD,mBAAOA,KAAKoF,KAAL,CAAWA,KAAX,KAAqB,cAA5B;AACD,WAFM,CAAP;AAGD;;AAED+X,2BAAmB;AACjB,cAAI,KAAKxe,kBAAT,EAA6B,OAAO,IAAP;AAC7B,cAAI,CAAC,KAAKd,WAAN,IAAqB,CAAC,KAAKof,6BAA/B,EAA8D,OAAO,KAAP;AAC9D,cAAI;AACF,iBAAKG,MAAL;AACD,WAFD,CAEE,OAAO9e,GAAP,EAAY;AACZ+e,oBAAQC,KAAR,CAAc,+BAAd,EAA+Chf,GAA/C;AACA,mBAAO,KAAP;AACD;AACD,iBAAO,IAAP;AACD;;AAED8e,iBAAS;AACP,cAAI9X,OAAO,IAAX;AACF,eAAK9G,QAAL,CAAcL,aAAd,CAA4B;AAC3BkB,kBAAMhB,IAAN,EAAY;AACXA,mBAAK2B,IAAL,CAAUud,KAAV,GAAkB;AACjB;AACA;AACA;AACAC,yBAAS,CAJQ;AAKjB;AACAC,+BAAe;AANE,eAAlB;AAQA;AAV0B,WAA5B;;AAaA;AACA,eAAKjf,QAAL,CAAcL,aAAd,CAA4B;AACxBuf,kBAAMrf,IAAN,EAAY;AACdsf,qBAAOC,OAAP,CAAevf,KAAK+E,KAAL,CAAW6E,QAA1B,EAAoCoB,OAApC,CAA4C,CAAC,CAACwU,KAAD,EAAQra,OAAR,CAAD,KAAsB;AACjEA,wBAAQO,cAAR,CAAuBsF,OAAvB,CAA+BhL,QAAQ;AACtCA,uBAAK2B,IAAL,CAAUud,KAAV,CAAgB/Z,OAAhB,GAA0BA,OAA1B;AACA,iBAFD;AAGA,eAJD;AAKA;AAP0B,WAA5B;;AAUA,eAAKsa,wBAAL;;AAEE,eAAKC,mBAAL;;AAEF,eAAKlgB,WAAL,CAAiBuB,QAAjB,CAA0B;AACzBsC,uBAAWsc,IAAX,EAAiB;AAChB1Y,mBAAK2Y,4BAAL,CAAkCD,IAAlC;AACA;AAHwB,WAA1B;;AAME,eAAKrf,kBAAL,GAA0B,IAA1B;AACF;;AAEA;AACAmf,mCAA0B;AACxB,cAAIxY,OAAO,IAAX;AACA,eAAKzH,WAAL,CAAiBuB,QAAjB,CAA0B;AAC3B8e,6BAAiBF,IAAjB,EAAuB;AACtB,kBAAIA,KAAKhe,IAAL,CAAUme,QAAd,EAAwB;AACxB,kBAAI,CAACH,KAAKjc,UAAL,CAAgBqc,sBAAhB,EAAL,EAA+C;AAC3C,kBAAIC,aAAa/Y,KAAKgZ,aAAL,CAAmBN,KAAKjc,UAAxB,CAAjB;;AAEJ,kBAAIwc,MAAMP,KAAKlE,GAAL,CAAS,QAAT,CAAV;AACA,kBAAI0E,SAASD,IAAIve,IAAJ,CAASud,KAAT,CAAe/Z,OAAf,IAA0B,MAAvC;AACA,kBAAImQ,WAAWqK,KAAKlE,GAAL,CAAS,UAAT,EAAqB9Z,IAArB,CAA0B+C,IAAzC;;AAEA,kBAAI0b,QAAQnZ,KAAK1G,iBAAL,CAAuBkb,GAAvB,CAA2BnG,QAA3B,CAAZ;AACA,kBAAI,CAAC8K,KAAL,EAAY;AACX;AACA,oBAAIC,SAAS,IAAI7f,GAAJ,EAAb;;AAEA6f,uBAAOC,GAAP,CAAWH,MAAX,EAAmB,CAACH,UAAD,CAAnB;AACA/Y,qBAAK1G,iBAAL,CAAuB+f,GAAvB,CAA2BhL,QAA3B,EAAqC+K,MAArC;AACA,eAND,MAMO;AACN,oBAAIE,WAAWH,MAAM3E,GAAN,CAAU0E,MAAV,CAAf;AACA,oBAAI,CAACI,QAAL,EAAe;AACdA,6BAAW,EAAX;AACAH,wBAAME,GAAN,CAAUH,MAAV,EAAkBI,QAAlB;AACA;AACDA,yBAAS7d,IAAT,CAAcsd,UAAd;AACA;AACD;AAzB0B,WAA1B;AA2BD;;AAEDN,8BAAqB;AACrB;AACE,eAAKvf,QAAL,CAAcL,aAAd,CAA4B;AAC1B,uDAA2CE,IAA3C,EAAiD;AAC/CA,mBAAK2B,IAAL,CAAUud,KAAV,CAAgBsB,eAAhB,GAAkCA,gBAAgBxgB,IAAhB,CAAlC;AACA,oBAAMygB,kBAAkBzgB,KAAK2B,IAAL,CAAUud,KAAV,CAAgBuB,eAAhB,GAAkC,EAA1D;AACA,oBAAMC,UAAU1gB,KAAK2B,IAAL,CAAUud,KAAV,CAAgBwB,OAAhB,GAA0B,IAAIlgB,GAAJ,EAA1C;AACA,oBAAMmgB,UAAU3gB,KAAK2B,IAAL,CAAUud,KAAV,CAAgByB,OAAhB,GAA0B,EAA1C;;AAEA3gB,mBAAKe,QAAL,CAAc;AACZ8e,iCAAiBF,IAAjB,EAAuB;AACrB,sBAAIA,KAAKjc,UAAL,CAAgBqc,sBAAhB,EAAJ,EAA8C;AAC9C,sBAAIa,UAAUjB,KAAKlE,GAAL,CAAS,QAAT,EAAmB9Z,IAAjC;AACA,sBAAI2T,WAAWqK,KAAKlE,GAAL,CAAS,UAAT,EAAqB9Z,IAArB,CAA0B+C,IAAzC;;AAEA,sBAAI0b,QAAQM,QAAQjF,GAAR,CAAYmF,OAAZ,CAAZ;AACA,sBAAI,CAACR,KAAL,EAAY;AACVM,4BAAQJ,GAAR,CAAYM,OAAZ,EAAqB,IAAInb,GAAJ,CAAQ,CAAC6P,QAAD,CAAR,CAArB;AACD,mBAFD,MAEO;AACL8K,0BAAMS,GAAN,CAAUvL,QAAV;AACD;AACF;AAZW,eAAd;;AAeAtV,mBAAKe,QAAL,CAAc;AACZ+f,gCAAgBC,GAAhB,EAAqB;AACnB,sBAAIA,IAAIC,GAAJ,CAAQ,UAAR,CAAJ,EAAyB;AACvBL,4BAAQje,IAAR,CAAaqe,IAAItF,GAAJ,CAAQ,UAAR,CAAb;AACD;AACF,iBALW;AAMZgD,+BAAewC,IAAf,EAAqB;AACnBR,kCAAgB/d,IAAhB,CAAqBue,IAArB;AACD;AARW,eAAd;AAUD;AAhCyB,WAA5B;AAkCD;;AAED;;;;;;;AAODrB,qCAA6B5f,IAA7B,EAAmC;AAClC,cAAIA,KAAK2B,IAAL,CAAUud,KAAV,CAAgBE,aAAhB,IAAiC,CAArC,EAAwC;AACvC,mBAAO,EAAP;AACA;;AAEDpf,eAAK2B,IAAL,CAAUud,KAAV,CAAgBE,aAAhB,IAAiC,CAAjC;;AAEA,cAAIpf,KAAK2B,IAAL,CAAUud,KAAV,CAAgBgC,OAApB,EAA6B;AAC5B,mBAAOlhB,KAAK2B,IAAL,CAAUud,KAAV,CAAgBgC,OAAvB;AACA;;AAED,cAAIA,UAAU,EAAd;AACE,cAAIC,kBAAkB,EAAtB;;AAEF,cAAInhB,KAAKohB,kBAAL,EAAJ,EAA+B;AAC3BD,8BAAkB,CAAC,EAAC1I,kBAAiBzY,IAAlB,EAAwB4J,UAAS,IAAInE,GAAJ,EAAjC,EAAD,CAAlB;AAEH,WAHD,MAGO,IAAIzF,KAAKoD,YAAL,EAAJ,EAAyB;AAC5B,gBAAI,CAACpD,KAAK0D,UAAL,CAAgB2d,kBAAhB,EAAL,EAA2C;AACzC,kBAAIlc,UAAUnF,KAAK2B,IAAL,CAAUud,KAAV,CAAgB/Z,OAA9B;AACA,kBAAIA,OAAJ,EAAa;AACX,iBAACA,QAAQnF,IAAT,EAAe,GAAGmF,QAAQQ,kBAA1B,EAA8CqF,OAA9C,CAAsDmH,QAAQ;AAC5D,uBAAKyN,4BAAL,CAAkCzN,IAAlC;AACA+O,0BAAQxe,IAAR,CAAayP,KAAKxQ,IAAL,CAAUud,KAAV,CAAgBgC,OAA7B;AACA/O,uBAAKxQ,IAAL,CAAUud,KAAV,CAAgBiC,eAAhB,CAAgCnW,OAAhC,CAAwCkV,OAAM;AAC5CA,wBAAItW,QAAJ,CAAaiX,GAAb,CAAiB1b,OAAjB;AACAgc,oCAAgBze,IAAhB,CAAqBwd,GAArB;AACD,mBAHD;AAID,iBAPD;AAQD;AACF;AACF,WAdI,MAcE,IAAIlgB,KAAK+f,sBAAL,MAAiC/f,KAAKshB,oBAAL,EAArC,EAAkE;AACvE,gBAAIC,MAAM,KAAKtB,aAAL,CAAmBjgB,IAAnB,CAAV;AACH,iBAAK4f,4BAAL,CAAkC2B,GAAlC;AACAL,sBAAUK,IAAI5f,IAAJ,CAASud,KAAT,CAAegC,OAAzB;AACGC,8BAAkBI,IAAI5f,IAAJ,CAASud,KAAT,CAAeiC,eAAjC;AACD,WALM,MAKA,IAAInhB,KAAKkW,UAAL,EAAJ,EAAuB;AAC/BgL,sBAAU,CAAClhB,IAAD,CAAV;AACA,WAFQ,MAEF,IAAIA,KAAKwhB,uBAAL,EAAJ,EAAoC;AAC1C,aAACxhB,KAAKyb,GAAL,CAAS,YAAT,CAAD,EAAyBzb,KAAKyb,GAAL,CAAS,WAAT,CAAzB,EAAgDzQ,OAAhD,CAAwD2U,QAAQ;AAC/D,mBAAKC,4BAAL,CAAkCD,IAAlC;AACAuB,sBAAQxe,IAAR,CAAaid,KAAKhe,IAAL,CAAUud,KAAV,CAAgBgC,OAA7B;AACIC,8BAAgBze,IAAhB,CAAqBid,KAAKhe,IAAL,CAAUud,KAAV,CAAgBiC,eAArC;AACJ,aAJD;AAKA,WANM,MAMA,IAAInhB,KAAKyhB,gBAAL,EAAJ,EAA6B;AACnC,kBAAM3S,SAAS9O,KAAKyb,GAAL,CAAS,QAAT,CAAf;AACA,gBAAIiG,kBAAkB,EAAtB;AACA,iBAAK9B,4BAAL,CAAkC9Q,MAAlC;AACAA,mBAAOnN,IAAP,CAAYud,KAAZ,CAAkBgC,OAAlB,CAA0BlW,OAA1B,CAAkC2W,QAAQ;AACzC,mBAAK/B,4BAAL,CAAkC+B,IAAlC;AACA,oBAAMzQ,OAAOyQ,KAAKlG,GAAL,CAAS,MAAT,CAAb;AACA,kBAAI,CAACvK,KAAKlO,gBAAL,EAAL,EAA8B;AAC7B;AACA,qBAAK4c,4BAAL,CAAkC1O,IAAlC;AACAgQ,wBAAQxe,IAAR,CAAawO,KAAKvP,IAAL,CAAUud,KAAV,CAAgBgC,OAA7B;AACA,eAJD,MAIO;AACNS,qBAAKhgB,IAAL,CAAUud,KAAV,CAAgByB,OAAhB,CAAwB3V,OAAxB,CAAgC8J,mBAAmB;AAClD,uBAAK8K,4BAAL,CAAkC9K,eAAlC;AACAoM,0BAAQxe,IAAR,CAAaoS,gBAAgBnT,IAAhB,CAAqBud,KAArB,CAA2BgC,OAAxC;AACMC,kCAAgBze,IAAhB,CAAqBoS,gBAAgBnT,IAAhB,CAAqBud,KAArB,CAA2BiC,eAAhD;AACN,iBAJD;AAKA;AACD;AACAO,8BAAgBhf,IAAhB,CAAqBif,IAArB;AACA,aAhBD;AAiBA3hB,iBAAK2B,IAAL,CAAUud,KAAV,CAAgBwC,eAAhB,GAAkCA,gBAAgB9e,IAAhB,EAAlC;AAEA,WAvBM,MAuBA,IAAI5C,KAAK8F,kBAAL,EAAJ,EAA+B;AACrC,kBAAM8a,UAAU5gB,KAAKyb,GAAL,CAAS,QAAT,CAAhB;AACA,iBAAKmE,4BAAL,CAAkCgB,OAAlC;;AAEA,gBAAI5N,MAAM4N,QAAQjf,IAAR,CAAaud,KAAb,CAAmBiC,eAAnB,CAAmCve,IAAnC,EAAV;AACAoQ,gBAAIhI,OAAJ,CAAYuR,UAAU;AACrB,mBAAKqF,aAAL,CAAmB5hB,KAAKyb,GAAL,CAAS,UAAT,EAAqB9Z,IAArB,CAA0B+C,IAA7C,EAAmD6X,MAAnD,EAA2DvR,OAA3D,CAAmEgV,cAAc;AAChF,qBAAKJ,4BAAL,CAAkCI,UAAlC;AACAkB,wBAAQxe,IAAR,CAAasd,WAAWre,IAAX,CAAgBud,KAAhB,CAAsBgC,OAAnC;AACKC,gCAAgBze,IAAhB,CAAqBsd,WAAWre,IAAX,CAAgBud,KAAhB,CAAsBiC,eAA3C;AACL,eAJD;AAKA,aAND;AAOA;AACCnhB,eAAK2B,IAAL,CAAUud,KAAV,CAAgBiC,eAAhB,GAAkCA,gBAAgBve,IAAhB,EAAlC;AACF5C,eAAK2B,IAAL,CAAUud,KAAV,CAAgBgC,OAAhB,GAA0BA,QAAQte,IAAR,EAA1B;AACA;;AAEA;AACDgf,sBAActM,QAAd,EAAwB4K,GAAxB,EAA6B;;AAE1B,cAAI3D,SAAS,EAAb;AACA,eAAKsF,gBAAL,CAAsB3B,IAAItW,QAA1B,EAAoCoB,OAApC,CAA4C7F,WAAS;;AAEnD,gBAAI2c,gBAAgB,KAAKvhB,iBAAL,CAAuBkb,GAAvB,CAA2BnG,QAA3B,KAAwC,IAAI9U,GAAJ,EAA5D;AACA,gBAAIuhB,qBAAqBD,cAAcrG,GAAd,CAAkB,MAAlB,KAA6B,EAAtD;AACAsG,+BAAmB/W,OAAnB,CAA2BgV,cAAczD,OAAO7Z,IAAP,CAAYsd,UAAZ,CAAzC;;AAEA,gBAAIO,WAAWuB,cAAcrG,GAAd,CAAkBtW,OAAlB,CAAf;AACA,gBAAIob,QAAJ,EAAc;AACZA,uBAASvV,OAAT,CAAiBgV,cAAczD,OAAO7Z,IAAP,CAAYsd,UAAZ,CAA/B;AACD;AACF,WAVD;;AAYA;AACF,cAAIY,UAAUV,IAAIzH,gBAAlB,CAhB4B,CAgBQ;AAClC,cAAImI,WAAWA,QAAQQ,kBAAR,EAAf,EAA4C;AAC1C,gBAAIpO,MAAM4N,QACPnF,GADO,CACH,YADG,EAEPrU,IAFO,CAEFpH,QAAQA,KAAKyb,GAAL,CAAS,KAAT,EAAgB9Z,IAAhB,CAAqB+C,IAArB,KAA8B4Q,QAFpC,CAAV;AAGA,gBAAGtC,GAAH,EAAQ;AACN,kBAAIA,IAAIgP,gBAAJ,EAAJ,EAA4B;AAC1BzF,uBAAO7Z,IAAP,CAAYsQ,IAAIyI,GAAJ,CAAQ,OAAR,CAAZ;AACD,eAFD,MAEO,IAAIzI,IAAIiP,cAAJ,EAAJ,EAA0B;AAC/B1F,uBAAO7Z,IAAP,CAAYsQ,GAAZ;AACD;AACF;AACF;AACH,iBAAOuJ,MAAP;AACA;;AAEA0D,sBAAcjgB,IAAd,EAAoB;AAClB,cAAIA,KAAKqhB,kBAAL,EAAJ,EAA+B,OAAOrhB,IAAP;AAC/B,cAAIA,KAAKkiB,qBAAL,EAAJ,EAAkC,OAAOliB,IAAP;AAClC,cAAIA,KAAK+f,sBAAL,EAAJ,EAAmC,OAAO/f,KAAKyb,GAAL,CAAS,OAAT,CAAP;AACnC,cAAIzb,KAAKshB,oBAAL,EAAJ,EAAiC;AAC/B,kBAAM9Y,KAAKxI,KAAKyb,GAAL,CAAS,IAAT,CAAX;AACA,gBAAIjT,GAAG2Z,SAAH,EAAJ,EAAoB,OAFW,CAEH;AAC5B,mBAAOniB,KAAKyb,GAAL,CAAS,MAAT,CAAP;AACD;AACD;AACD;;AAGD;;;;;;;;;;AAUAoG,yBAAiBjY,QAAjB,EAA2B;;AAEzB;;;;AAIA,cAAI2S,SAAS3S,QAAb;AACAA,mBAASoB,OAAT,CAAiB7F,WAAS;AACxBA,oBAAQnF,IAAR,CAAa2B,IAAb,CAAkBud,KAAlB,CAAwBiC,eAAxB,CAAwCnW,OAAxC,CAAgDkV,OAAK;AACnD,kBAAGA,IAAItW,QAAP,EAAiB;AACfsW,oBAAItW,QAAJ,CAAaoB,OAAb,CAAqBmH,QAAQoK,OAAOsE,GAAP,CAAW1O,IAAX,CAA7B;AACD;AACF,aAJD;AAKD,WAND;;AAQA,iBAAOoK,MAAP;AACD;;AAEF;;;;AAIA6F,4BAAoBpiB,IAApB,EAA0B;AACvB,cAAI,CAAC,KAAK8e,gBAAL,EAAL,EAA8B,OAAO,IAAIrZ,GAAJ,EAAP;;AAE9B,cAAIzF,KAAK2B,IAAL,CAAU0gB,YAAV,IAA0B,IAA9B,EAAoC;AAClC,mBAAOriB,KAAK2B,IAAL,CAAU0gB,YAAjB;AACD;;AAEH,iBAAO,KAAKC,oBAAL,CAA0BtiB,IAA1B,CAAP;AACA;;AAEDsiB,6BAAqBtiB,IAArB,EAA2B;AACxB,gBAAMiH,OAAO,IAAb;AACF,cAAI,CAACjH,KAAK2B,IAAL,CAAUud,KAAV,CAAgBC,OAAhB,IAA2B,CAA5B,KAAkC,CAAtC,EAAyC;AACxC,mBAAOnf,KAAK2B,IAAL,CAAUud,KAAV,CAAgBmD,YAAhB,IAAgC,IAAI5c,GAAJ,EAAvC;AACA;;AAED,cAAIzF,KAAK2B,IAAL,CAAUud,KAAV,CAAgBmD,YAApB,EAAkC;AACjC;AACA,mBAAOriB,KAAK2B,IAAL,CAAUud,KAAV,CAAgBmD,YAAvB;AACA;;AAED,cAAIA,eAAe,IAAI5c,GAAJ,CAAQ,CAAC,GAAG,KAAKoc,gBAAL,CAAsB7hB,KAAK2B,IAAL,CAAUud,KAAV,CAAgBsB,eAAtC,CAAJ,EAA4DrhB,GAA5D,CAAgEgG,WAAW,CAAC,GAAGA,QAAQQ,kBAAZ,CAA3E,EAA4G/C,IAA5G,EAAR,CAAnB;AACA5C,eAAK2B,IAAL,CAAUud,KAAV,CAAgBuB,eAAhB,CAAgCzV,OAAhC,CAAwCwK,kBAAkB;AACzDA,2BAAe7T,IAAf,CAAoBud,KAApB,CAA0BwC,eAA1B,CAA0C1W,OAA1C,CAAkD8D,UAAU;AAC3D,kBAAIxQ,EAAE4X,UAAF,CAAapH,MAAb,CAAJ,EAA0B;AACzB,qBAAKwT,oBAAL,CAA0BxT,MAA1B,EAAkC9D,OAAlC,CAA0CuX,OAAOF,aAAaxB,GAAb,CAAiB0B,GAAjB,CAAjD;AACA;;AAED,kBAAIjkB,EAAEyhB,sBAAF,CAAyBjR,MAAzB,CAAJ,EAAsC;AACrC,sBAAM/H,QAAQ,KAAKkZ,aAAL,CAAmBnR,MAAnB,CAAd;AACA,oBAAIxQ,EAAE4X,UAAF,CAAanP,KAAb,KAAuBzI,EAAE8b,yBAAF,CAA4BrT,KAA5B,CAA3B,EAA+D;AAC9D,uBAAKub,oBAAL,CAA0Bvb,KAA1B,EAAiCiE,OAAjC,CAAyCuX,OAAOF,aAAaxB,GAAb,CAAiB0B,GAAjB,CAAhD;AACA;AACD;;AAED,kBAAIjkB,EAAEgjB,oBAAF,CAAuBxS,MAAvB,CAAJ,EAAoC;AACnC;AACA;AACD,aAfD;AAgBA,WAjBD;;AAmBA,cAAI9O,KAAK2B,IAAL,CAAUud,KAAV,CAAgBwB,OAAhB,CAAwB8B,IAA5B,EAAkC;AACjC,iBAAK,MAAM,CAAC5B,OAAD,EAAUja,OAAV,CAAX,IAAiC3G,KAAK2B,IAAL,CAAUud,KAAV,CAAgBwB,OAAhB,CAAwBnB,OAAxB,EAAjC,EAAoE;AAC/D,kBAAIjhB,EAAEyH,gBAAF,CAAmB6a,OAAnB,CAAJ,EAAiC;AACrC,mBAAK,MAAM6B,MAAX,IAAqB9b,OAArB,EAA8B;AACtBM,qBAAK2a,aAAL,CAAmBa,MAAnB,EAA2B,EAAC7Y,UAAU,IAAInE,GAAJ,CAAQ,CAACmb,QAAQ1B,KAAR,CAAc/Z,OAAf,CAAR,CAAX,EAA3B,EAAyE6F,OAAzE,CAAiFgV,cAAc;AACrGqC,+BAAaxB,GAAb,CAAiBb,UAAjB;AACA,iBAFM;AAGP;AACD;AACD;AACDhgB,eAAK2B,IAAL,CAAUud,KAAV,CAAgBmD,YAAhB,GAA+BA,YAA/B;AACA,iBAAOA,YAAP;AACA;;AAEAK,kCAA0B;AACxB,iBAAO,KAAKjiB,MAAL,KAAgB,KAAKA,MAAL,GAAc,KAAKkiB,cAAL,EAA9B,CAAP;AACD;;AAEDA,yBAAiB;AACf,gBAAMC,WAAW,EAAjB;AACA,eAAKpjB,WAAL,CAAiBuB,QAAjB,CAA0B;AACxB0d,2BAAeze,IAAf,EAAqB;AACnB,kBAAI2e,QAAQ3e,IAAR,CAAJ,EAAoB;AAClB4iB,yBAASlgB,IAAT,CAAc1C,IAAd;AACD;AACF;AALuB,WAA1B;AAOA,iBAAO4iB,QAAP;AACD;;AAn6DkC;;yBAAhBnkB,e;;;;;;;;;;;;;;;;AAu6DrB;;AAEA,YAAMokB,wBAAwB,OAA9B;;;;;;;;;;;;;;;AAEA,eAASrC,eAAT,CAAyBxgB,IAAzB,EAA+B;AAC9B,cAAM4J,WAAW,IAAInE,GAAJ,EAAjB;AACAzF,aAAKe,QAAL,CAAc;AACb+hB,+BAAqBta,EAArB,EAAyB;AACxB,kBAAMua,eAAe/iB,KAAK+E,KAAL,CAAWE,UAAX,CAAsBuD,GAAG7G,IAAH,CAAQ+C,IAA9B,CAArB;AACA,gBAAI,CAACqe,YAAL,EAAmB;AACnB,kBAAMC,gBAAgBxa,GAAGzD,KAAH,CAASE,UAAT,CAAoBuD,GAAG7G,IAAH,CAAQ+C,IAA5B,CAAtB;AACA,gBAAIqe,iBAAiBC,aAArB,EAAoC;AACnCpZ,uBAASiX,GAAT,CAAamC,aAAb;AACA;AACD;AARY,SAAd;AAUA,eAAOpZ,QAAP;AACA;;AAED,eAAS+U,OAAT,CAAiB3e,IAAjB,EAAuB;AACtB,eAAO1B,EAAEmjB,gBAAF,CAAmBzhB,IAAnB,KACH1B,EAAE8E,YAAF,CAAepD,KAAK2B,IAAL,CAAUmN,MAAzB,CADG,IAEH9O,KAAK2B,IAAL,CAAUmN,MAAV,CAAiBpK,IAAjB,KAA0Bme,qBAFvB,IAGH,CAAC7iB,KAAK+E,KAAL,CAAWC,UAAX,CAAsB6d,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 ContextMenu from 'src/client/contextmenu.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(livelyCodeMirror, codeMirror) {\n    this.livelyCodeMirror = livelyCodeMirror;\n    this.codeMirror = codeMirror;\n    if (!codeMirror) debugger;\n    this.codeChanged();\n  }\n\n  get editor() {\n    return this.codeMirror;\n  }\n\n  get selectionRanges() {\n    if (this.editor.listSelections().length == 0) {\n      return this.firstSelection;\n    }\n    return this.editor.listSelections().map(range);\n  }\n\n  get firstSelection() {\n    return range(this._getFirstSelectionOrCursorPosition());\n  }\n\n  _getFirstSelectionOrCursorPosition() {\n    if (this.editor.listSelections().length == 0) {\n      return { anchor: this.editor.getCursor(), head: this.editor.getCursor() };\n    }\n    return this.editor.listSelections()[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.updateColorPicker();\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 in the editor\n   */\n  selectNodes(nodes, selectStringContentsOnly = false) {\n    const ranges = nodes.map(node => {\n      const [anchor, head] = range(node.loc).asCM();\n      if (selectStringContentsOnly && t.isStringLiteral(node)) {\n        anchor.ch++;\n        head.ch--;\n      }\n      return { anchor, head };\n    });\n    // #TODO: include primary selection\n    if (ranges.length == 1) {\n      this.editor.setSelection(ranges[0].head, ranges[0].anchor);\n    } else {\n      this.editor.setSelections(ranges);\n    }\n    this.codeMirror.scrollIntoView({ from: ranges[0].head, to: ranges[0].anchor }, 120);\n  }\n\n  /** \n   * Select the text corresponding to the given paths in the editor\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(programPath) {\n    let colorPaths = [];\n    const colorRegex = /(0[xX]|#)[0-9a-fA-F]{6}$/g;\n    programPath.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  async openMenu() {\n\n    function fa(name, ...modifiers) {\n      return `<i class=\"fa fa-${name} ${modifiers.map(m => 'fa-' + m).join(' ')}\"></i>`;\n    }\n\n    const myself = this;\n    /*MD ### Generate Submenus MD*/\n\n    async function generateGenerationSubmenu() {\n\n      let submenu = [['Class', () => {\n        menu.remove();\n        myself.generateClass();\n      }, '→', fa('suitcase')]];\n\n      const selectedPath = myself.getInnermostPathContainingSelection(myself.programPath, myself.firstSelection);\n\n      //add testcase if in describe\n      if (myself.isInDescribe(selectedPath)) {\n        submenu.unshift(['Testcase', () => {\n          menu.remove();\n          myself.generateTestCase();\n        }, '→', fa('suitcase')]);\n      }\n\n      if (myself.isDirectlyIn([\"ClassBody\", \"ObjectExpression\"], selectedPath)) {\n        submenu.push(['Getter', () => {\n          menu.remove();\n          myself.generateGetter();\n        }, '→', fa('suitcase')], ['Setter', () => {\n          menu.remove();\n          myself.generateSetter();\n        }, '→', fa('suitcase')]);\n      }\n\n      return submenu;\n    }\n\n    async function generateImportSubmenu() {\n      let { identName, functions, classes } = await myself.findImports();\n      let submenu = [];\n      if (!identName || functions.length == 0 && classes.length == 0) {\n        submenu.push(['none', () => {\n          menu.remove();\n        }, '', '']);\n      } else {\n        functions.forEach(url => submenu.push([url.replace(lively4url, ''), () => {\n          menu.remove();\n          myself.addImport(url, identName, true);\n        }, '-', fa('share-square-o')]));\n        classes.forEach(cl => submenu.push([cl.name + \", \" + cl.url.replace(lively4url, ''), () => {\n          menu.remove();\n          myself.addImport(cl.url, cl.name, false);\n        }, '-', fa('share-square-o')]));\n      }\n      return submenu;\n    }\n\n    /*MD ### Generate Factoring Menu MD*/\n\n    const menuItems = [['selection to local variable', () => {\n      menu.remove();\n      this.extractExpressionIntoLocalVariable();\n    }, '→', fa('share-square-o', 'flip-horizontal')], ['wrap into active expression', () => {\n      menu.remove();\n      this.wrapExpressionIntoActiveExpression();\n    }, '→', fa('suitcase')], ['Rename', () => {\n      menu.remove();\n      this.rename();\n    }, 'Alt+R', fa('suitcase')], ['Extract Method', () => {\n      menu.remove();\n      this.extractMethod();\n    }, 'Alt+M', fa('suitcase'), () => {\n      const selection = this.selectMethodExtraction(this.programPath, true);\n      if (selection) {\n        this.changedSelectionInMenu = true;\n        this.selectPaths(selection.selectedPaths);\n      } else {\n        this.changedSelectionInMenu = false;\n      }\n    }, () => {\n      if (this.changedSelectionInMenu) {\n        this.editor.undoSelection();\n      }\n    }], ['Generate HTML Accessors', () => {\n      menu.remove();\n      this.generateHTMLAccessors();\n    }, 'Alt+H', fa('suitcase')], ['Print References', () => {\n      this.printAllBindings();\n      menu.remove();\n    }, 'Alt+I', fa('suitcase')], ['Generate', generateGenerationSubmenu()], ['Import', generateImportSubmenu()]];\n    var menuPosition = this.codeMirror.cursorCoords(false, \"window\");\n\n    const menu = await ContextMenu.openIn(document.body, { clientX: menuPosition.left, clientY: menuPosition.bottom }, undefined, document.body, menuItems);\n    menu.addEventListener(\"DOMNodeRemoved\", () => {\n      this.focusEditor();\n    });\n  }\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.editor.setSelection({ line, ch: 0 });\n    });\n  }\n\n  async compileListOfIDs() {\n    let editor = lively.allParents(this.livelyCodeMirror, undefined, true).find(ele => ele.tagName && ele.tagName === 'LIVELY-EDITOR');\n    let jsURI = encodeURI(editor.shadowRoot.querySelector(\"#filename\").value);\n    const htmlURI = jsURI::replaceFileEndingWith('html');\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    this.focusEditor();\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.focusEditor();\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.focusEditor();\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Accessors MD*/\n\n  get sourceCode() {\n    return this.livelyCodeMirror.value;\n  }\n  set sourceCode(text) {\n    this.livelyCodeMirror.value = text;\n    this.codeChanged();\n    return this.livelyCodeMirror.value;\n  }\n\n  focusEditor() {\n    this.livelyCodeMirror.focus();\n  }\n\n  get scrollInfo() {\n    return this.codeMirror.getScrollInfo();\n  }\n  scrollTo(scrollInfo) {\n    this.codeMirror.scrollIntoView({\n      left: scrollInfo.left,\n      top: scrollInfo.top,\n      right: scrollInfo.left + scrollInfo.width,\n      bottom: scrollInfo.top + scrollInfo.height\n    }, 120);\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  /*MD ## Color Picker MD*/\n\n  updateColorPicker() {\n    const pPath = this.programPath;\n    if (!pPath) {\n      return;\n    }\n    const old = this.editor.getAllMarks();\n    old.forEach(marker => {\n      if (marker.type === \"bookmark\") {\n        marker.clear();\n      }\n    });\n    const colorLiterals = this.getColorLiterals(pPath);\n    colorLiterals.forEach(path => {\n      const location = { line: path.node.loc.end.line - 1, ch: path.node.loc.end.column };\n      var picker = document.createElement(\"input\");\n      picker.type = \"color\";\n      picker.value = path.node.value;\n      picker.height = \"15\";\n      picker.width = \"15\";\n      const bookmark = this.editor.setBookmark(location, picker);\n      picker.addEventListener('change', event => {\n        const currentLocation = bookmark.find();\n        this.updateColor(currentLocation, event.target.value);\n      });\n    });\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    this.updateColorPicker();\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"]}