{"version":3,"sources":["https://lively-kernel.org/lively4/swt1-debugging/src/client/reactive/active-expression-rewriting/active-expression-rewriting.js"],"names":["BaseActiveExpression","frameBasedAExpr","Stack","CompositeKey","InjectiveMap","BidirectionalMultiMap","DualKeyMap","isFunction","lively","_","diff","AExprRegistry","setGlobal","getGlobal","setLocal","getLocal","deleteMember","setMemberBitwiseOR","setMemberBitwiseXOR","setMemberBitwiseAND","setMemberUnsignedRightShift","setMemberRightShift","setMemberLeftShift","setMemberExponentiation","setMemberRemainder","setMemberDivision","setMemberMultiplication","setMemberSubtraction","setMemberAddition","setMember","getAndCallMember","getMember","traceMember","reset","aexpr","relatedFiles","analysisStack","expressionAnalysisMode","window","__expressionAnalysisMode__","ExpressionAnalysis","recalculateDependencies","findUp","currentAExpr","Error","withElement","dependencies","Set","value","isError","evaluateToCurrentValue","e","console","error","message","applyDependencies","top","associateDependency","dependency","add","currentDependencies","all","currentSet","removedDependencies","filter","has","newDependencies","forEach","DependenciesToAExprs","disassociate","associate","matching","index","findIndex","dependency2","equalish","push","removed","getKey","added","currentVersion","splice","length","logEvent","map","d","d1","d2","type","isEqual","Dependency","getOrCreateFor","context","identifier","ContextAndIdentifierToDependencies","getOrCreate","DependencyKey","constructor","_type","classFilePath","__classFilePath__","isTracked","hooks","updateTracking","hasAExprsForDep","untrack","track","hook","getHooks","getLocations","then","locations","DebuggingCache","updateFiles","loc","file","ae","getAExprsForDep","meta","get","contextIdentifierValue","isGlobal","isGlobalDependency","sourceCodeHook","SourceCodeHook","associateWithHook","dataStructure","Array","Map","DataStructureHook","getOrCreateForDataStructure","wrappingHook","PropertyWrappingHook","getOrCreateForProperty","HTMLElement","tagName","endsWith","MutationObserverHook","getOrCreateForElement","EventBasedHook","FrameBasedHook","instance","addDependency","removeSecondary","removeDependency","undefined","notifyAExprs","location","aexprs","DependencyManager","checkAndNotifyAExprs","isMemberDependency","isLocalDependency","self","getName","toString","name","getAsDependencyDescription","object","property","scope","AEDebuggingCache","registeredDebuggingViews","debouncedUpdateDebuggingViews","debounce","updateDebggingViews","changedFiles","registerFileForAEDebugging","url","triplesCallback","callback","valid","getDependencyTriplesForFile","getTripletsForAE","result","getDepsForAExpr","updateFile","oldCode","newCode","lineMapping","calculateMapping","getAEsInFile","remapLocation","getHooksInFile","lineChanged","start","line","diff2","lineChanged2","end","notify","mapping","dmp","diff_match_patch","a","diff_linesToChars_","lineText1","chars1","lineText2","chars2","lineArray","diffs","diff_main","originalLine","newLine","recentDeletions","recentAdditions","data","i","matchingLines","Math","max","substring","diff_charsToLines_","files","some","includes","concat","getDependencies","allHooks","allValues","flatMap","dep","hooksWithLocations","Promise","find","_depsToAExprs","_AEsPerFile","remove","disconnectAllForAExpr","delete","deps","removeAllLeftFor","aes","entries","hasLeft","from","getRightsFor","hasRight","getLeftsFor","hasDepsForAExpr","clear","getAllLeft","getDependency","equals","other","isArray","getCurrentVersion","getValue","identifer","DataStructureHookByDataStructure","WeakMap","PropertyWrappingHookByProperty","MutationObserverHookByHTMLElement","EventBasedHookByHTMLElement","Hook","installed","addLocation","l","uniqWith","informationString","notifyDependencies","TracingHandler","findRegistrationLocation","install","uninstall","monitorProperties","getPrototypeDescriptors","obj","proto","prototype","descriptors","Object","getOwnPropertyDescriptors","key","desc","wrapProperty","descriptor","after","defineProperty","assign","args","apply","call","myself","prototypeDescriptors","ignoredDescriptorKeys","addDescriptor","__compareAExprResults__","configurable","enumerable","getOwnPropertyDescriptor","set","element","_element","o","MutationObserver","mutations","observer","changeHappened","observe","attributes","attributeFilter","attributeOldValue","characterData","characterDataOldValue","childList","subtree","addEventListener","editor","on","_instance","initializeAe","x","isMeta","onChange","RewritingActiveExpression","func","strategy","updateDependencies","dispose","disconnectAllFor","asAExpr","isDisabled","supportsDependencies","DependencyAPI","sharedDependenciesWith","otherAExpr","ownDependencies","otherDependencies","own","shared","computeDiff","_aexpr","locals","members","globals","globalRef","global","evaluationStack","checkAndNotify","associateMember","prop","associateGlobal","globalName","associateLocal","varName","memberUpdated","globalUpdated","localUpdated","stack","frames","frame","slice","getSourceLocBabelStyle","notificationFrame","log","val"],"mappings":";;;;;;;AAMSA,0B,qBAAAA,oB;;AACGC,qB;;AAELC,W;;AACAC,kB;;AACAC,kB;;AACAC,2B;;AACAC,gB;;AACEC,gB,UAAAA,U;;AACFC,Y;;AACAC,O;;AACAC,U;;AACEC,mB,wDAAAA,a;;;;;;;;;;;+BAgsCOC,0C;;;;;;;;;;;;;;+BANAC,0C;;;;;;;;;;;;;;8BALAC,yC;;;;;;;;;;;;;;8BAPAC,yC;;;;;;;;;;;;;;kCANAC,6C;;;;;;;;;;;;;;wCANAC,mD;;;;;;;;;;;;;;yCANAC,oD;;;;;;;;;;;;;;yCANAC,oD;;;;;;;;;;;;;;iDANAC,4D;;;;;;;;;;;;;;yCANAC,oD;;;;;;;;;;;;;;wCANAC,mD;;;;;;;;;;;;;;6CANAC,wD;;;;;;;;;;;;;;wCANAC,mD;;;;;;;;;;;;;;uCANAC,kD;;;;;;;;;;;;;;6CANAC,wD;;;;;;;;;;;;;;0CANAC,qD;;;;;;;;;;;;;;uCANAC,kD;;;;;;;;;;;;;;+BANAC,0C;;;;;;;;;;;;;;sCARAC,iD;;;;;;;;;;;;;;+BARAC,0C;;;;;;;;;;;;;;iCANAC,4C;;;;;;;;;;;;;;2BATAC,sC;;;;;;;;;;;;;;2BAlGAC,sC;;;;;;;;;;;;;;AAlhBDC,uD;;;;;;;;;;;;;AAndNnC,+D;;;;;;;;;;;;;AACGC,0D;;;;;;;;;;;;;AAELC,gD;;;;;;;;;;;;;AACAC,uD;;;;;;;;;;;;;AACAC,uD;;;;;;;;;;;;;AACAC,gE;;;;;;;;;;;;;AACAC,qD;;;;;;;;;;;;;AACEC,qD;;;;;;;;;;;;;AACFC,iD;;;;;;;;;;;;;AACAC,4C;;;;;;;;;;;;;AACAC,+C;;;;;;;;;;;;;AACEC,wD;;;;;;;;;AAET;;AAEA,YAAMyB,gBAAgB,IAAIlC,KAAJ,EAAtB;;;;;;;;AAAMkC,wD;;;;;;;AAEN,UAAIC,yBAAyB,KAA7B;;;;;;;AAAIA,iE;;;;;;;AACJC,aAAOC,0BAAP,GAAoC,KAApC;;AAEA,YAAMC,kBAAN,CAAyB;;AAEvB,eAAOC,uBAAP,CAA+BP,KAA/B,EAAsC;AACpC,cAAIE,cAAcM,MAAd,CAAqB,CAAC,EAAEC,YAAF,EAAD,KAAsBA,iBAAiBT,KAA5D,CAAJ,EAAwE;AACtE,kBAAM,IAAIU,KAAJ,CAAU,4FAAV,CAAN;AACD;;AAED,cAAI;AACF,gIAAyB,IAAzB;AACAN,mBAAOC,0BAAP,GAAoCF,sBAApC;;AAEA;AACAD,0BAAcS,WAAd,CAA0B,EAAEF,cAAcT,KAAhB,EAAuBY,cAAc,IAAIC,GAAJ,EAArC,EAA1B,EAA4E,MAAM;AAChF,kBAAI;AACF,sBAAM,EAAEC,KAAF,EAASC,OAAT,KAAqBf,MAAMgB,sBAAN,EAA3B;AACD,eAFD,CAEE,OAAMC,CAAN,EAAS;AACTC,wBAAQC,KAAR,CAAc,wCAAd,EAAwDF,EAAEG,OAA1D;AACD,eAJD,SAIS;AACP,qBAAKC,iBAAL;AACD;AACF,aARD;AASD,WAdD,SAcU;AACR,gIAAyB,CAAC,CAACnB,cAAcoB,GAAd,EAA3B;AACAlB,mBAAOC,0BAAP,GAAoCF,sBAApC;AACD;AACF;;AAED,eAAOoB,mBAAP,CAA2BC,UAA3B,EAAuC;AACrC,gBAAM,EAAEZ,YAAF,KAAmBV,cAAcoB,GAAd,EAAzB;AACAV,uBAAaa,GAAb,CAAiBD,UAAjB;AACD;;AAED,eAAOH,iBAAP,GAA2B;AACzB,gBAAM,EAAEZ,YAAF,EAAgBG,YAAhB,KAAiCV,cAAcoB,GAAd,EAAvC;;AAEA,gBAAMI,sBAAsBjB,aAAaG,YAAb,GAA4Be,GAA5B,EAA5B;AACA,gBAAMC,aAAa,IAAIf,GAAJ,CAAQa,mBAAR,CAAnB;AACA,cAAIG,sBAAsBH,oBACvBI,MADuB,CAChBN,cAAc,CAACZ,aAAamB,GAAb,CAAiBP,UAAjB,CADC,CAA1B;AAEA,gBAAMQ,kBAAkB,CAAC,GAAGpB,YAAJ,EACrBkB,MADqB,CACdN,cAAc,CAACI,WAAWG,GAAX,CAAeP,UAAf,CADD,CAAxB;;AAGAK,8BACGI,OADH,CACWT,cAAcU,qBAAqBC,YAArB,CAAkCX,UAAlC,EAA8Cf,YAA9C,CADzB;AAEAG,uBAAaqB,OAAb,CAAqBT,cAAc;AACjCU,iCAAqBE,SAArB,CAA+BZ,UAA/B,EAA2Cf,YAA3C;AACD,WAFD;;AAIA,gBAAM4B,WAAW,EAAjB;AACAR,gCAAsBA,oBAAoBC,MAApB,CAA4BN,UAAD,IAAgB;AAC/D,kBAAMc,QAAQN,gBAAgBO,SAAhB,CAA2BC,eAAe,KAAKC,QAAL,CAAcjB,UAAd,EAA0BgB,WAA1B,CAA1C,CAAd;AACA,gBAAGF,SAAS,CAAZ,EAAe;AACbD,uBAASK,IAAT,CAAc,EAACC,SAASnB,WAAWoB,MAAX,EAAV,EAA+BC,OAAOb,gBAAgBM,KAAhB,EAAuBM,MAAvB,EAAtC,EAAd;AACApB,yBAAWsB,cAAX,GAA4Bd,gBAAgBM,KAAhB,CAA5B;AACAN,8BAAgBe,MAAhB,CAAuBT,KAAvB,EAA8B,CAA9B;AACA,qBAAO,KAAP;AACD;AACD,mBAAO,IAAP;AACD,WATqB,CAAtB;AAUA,cAAGN,gBAAgBgB,MAAhB,GAAyB,CAAzB,IAA8BnB,oBAAoBmB,MAApB,GAA6B,CAA3D,IAAgEX,SAASW,MAAT,GAAkB,CAArF,EAAwF;AACtFvC,yBAAawC,QAAb,CAAsB,sBAAtB,EAA8C,EAAEJ,OAAOb,gBAAgBkB,GAAhB,CAAoBC,KAAKA,EAAEP,MAAF,EAAzB,CAAT,EAA+CD,SAASd,oBAAoBqB,GAApB,CAAwBC,KAAKA,EAAEP,MAAF,EAA7B,CAAxD,EAAkGP,QAAlG,EAA9C;AACD;AACF;;AAED,eAAOI,QAAP,CAAgBW,EAAhB,EAAoBC,EAApB,EAAwB;AACtB,cAAGD,GAAGE,IAAH,OAAcD,GAAGC,IAAH,EAAjB,EAA4B,OAAO,KAAP;AAC5B,iBAAO/E,EAAEgF,OAAF,CAAUH,GAAGR,MAAH,EAAV,EAAuBS,GAAGT,MAAH,EAAvB,CAAP;AACD;;AAnEsB;;;;;;;;AAAnBtC,6D;;;;;;;AAuEN,YAAMkD,UAAN,CAAiB;AACf,eAAOC,cAAP,CAAsBC,OAAtB,EAA+BC,UAA/B,EAA2CL,IAA3C,EAAiD;AAC/C,iBAAOM,mCAAmCC,WAAnC,CAA+CH,OAA/C,EAAwDC,UAAxD,EAAoE,MAAM,IAAIH,UAAJ,CAAeE,OAAf,EAAwBC,UAAxB,EAAoCL,IAApC,CAA1E,CAAP;AACD;;AAED;AACAV,iBAAS;AACP,iBAAO,IAAIkB,aAAJ,CAAkB,KAAKJ,OAAvB,EAAgC,KAAKC,UAArC,CAAP;AACD;;AAED;AACAI,oBAAYL,OAAZ,EAAqBC,UAArB,EAAiCL,IAAjC,EAAuC;AACrC,eAAKU,KAAL,GAAaV,IAAb;AACA,eAAKW,aAAL,GAAqBP,QAAQQ,iBAA7B;AACA,eAAKC,SAAL,GAAiB,KAAjB;AACA,eAAKC,KAAL,GAAa,EAAb;AACA,eAAKV,OAAL,GAAeA,OAAf;AACA,eAAKC,UAAL,GAAkBA,UAAlB;AACD;;AAEDU,yBAAiB;AACf,cAAI,KAAKF,SAAL,KAAmBjC,qBAAqBoC,eAArB,CAAqC,IAArC,CAAvB,EAAmE;AACjE;AACD;AACD,cAAI,KAAKH,SAAT,EAAoB;AAClB,iBAAKI,OAAL;AACD,WAFD,MAEO;AACL,iBAAKC,KAAL;AACD;AACD,eAAK,MAAMC,IAAX,IAAmB,KAAKC,QAAL,EAAnB,EAAoC;AAClCD,iBAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAaC,eAAeC,WAAf,CAA2BF,UAAU3B,GAAV,CAAc8B,OAAOA,IAAIC,IAAzB,CAA3B,CAAtC;AACD;AACD,eAAK,MAAMC,EAAX,IAAiBhD,qBAAqBiD,eAArB,CAAqC,IAArC,CAAjB,EAA6D;AAC3D,gBAAID,GAAGE,IAAH,GAAUrD,GAAV,CAAc,UAAd,CAAJ,EAA+B;AAC7B+C,6BAAeC,WAAf,CAA2B,CAACG,GAAGE,IAAH,GAAUC,GAAV,CAAc,UAAd,EAA0BJ,IAA3B,CAA3B;AACD;AACF;AACF;;AAEDT,gBAAQ;AACN,eAAKL,SAAL,GAAiB,IAAjB;;AAEA,gBAAM,CAACT,OAAD,EAAUC,UAAV,EAAsB7C,KAAtB,IAA+B,KAAKwE,sBAAL,EAArC;AACA,gBAAMC,WAAW,KAAKC,kBAAL,EAAjB;;AAEA;AACA;AACA,eAAKC,cAAL,GAAsB,IAAIC,cAAJ,CAAmBhC,OAAnB,EAA4BC,UAA5B,CAAtB;AACA,eAAKgC,iBAAL,CAAuB,KAAKF,cAA5B;;AAEA;AACA,cAAIG,aAAJ;AACA,cAAI,KAAK5B,KAAL,KAAe,QAAnB,EAA6B;AAC3B4B,4BAAgBlC,OAAhB;AACD,WAFD,MAEO,IAAI,KAAKM,KAAL,KAAe,OAAnB,EAA4B;AACjC4B,4BAAgB9E,KAAhB;AACD;AACD,cAAI8E,yBAAyBC,KAAzB,IAAkCD,yBAAyB/E,GAA3D,IAAkE+E,yBAAyBE,GAA/F,EAAoG;AAClG,iBAAKH,iBAAL,CAAuBI,kBAAkBC,2BAAlB,CAA8CJ,aAA9C,CAAvB;AACD;;AAED;AACA,cAAIL,YAAY5B,eAAe,MAA/B,EAAuC;AACrC,kBAAMsC,eAAeC,qBAAqBC,sBAArB,CAA4CxC,UAA5C,CAArB;AACA,iBAAKgC,iBAAL,CAAuBM,YAAvB;AACD;;AAED;AACA,cAAI,KAAKjC,KAAL,KAAe,QAAf,IAA2BN,mBAAmB0C,WAAlD,EAA+D;AAC7D;AACA,gBAAI1C,QAAQ2C,OAAR,KAAoB,cAApB,IAAsC,EAAE3C,QAAQ2C,OAAR,KAAoB,WAApB,KAAoC1C,eAAe,MAAf,IAAyBA,eAAe,WAA5E,CAAF,CAAtC,IAAqI,CAACD,QAAQ2C,OAAR,CAAgBC,QAAhB,CAAyB,OAAzB,CAA1I,EAA6K;AAC3K;AACA,mBAAKX,iBAAL,CAAuBY,qBAAqBC,qBAArB,CAA2C9C,OAA3C,CAAvB;AACD;AACF;;AAED;AACA,cAAI,KAAKM,KAAL,KAAe,QAAf,IAA2BN,mBAAmB0C,WAAlD,EAA+D;AAC7D;AACA;AACA;AACA,iBAAKT,iBAAL,CAAuBc,eAAeD,qBAAf,CAAqC9C,OAArC,CAAvB;AACD;;AAED;AACA;AACA,cAAI6B,YAAY5B,eAAe,MAA/B,EAAuC;AACrC;AACA,iBAAKgC,iBAAL,CAAuBe,eAAeC,QAAtC;AACD;AACF;;AAEDhB,0BAAkBlB,IAAlB,EAAwB;AACtB,eAAKL,KAAL,CAAW1B,IAAX,CAAgB+B,IAAhB;AACAA,eAAKmC,aAAL,CAAmB,IAAnB;AACD;;AAEDrC,kBAAU;AACR,eAAKJ,SAAL,GAAiB,KAAjB;AACAP,6CAAmCiD,eAAnC,CAAmD,KAAKnD,OAAxD,EAAiE,KAAKC,UAAtE;;AAEA;AACA,eAAK,MAAMc,IAAX,IAAmB,KAAKL,KAAxB,EAA+B;AAC7BK,iBAAKqC,gBAAL,CAAsB,IAAtB;AACArC,iBAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAaC,eAAeC,WAAf,CAA2BF,UAAU3B,GAAV,CAAc8B,OAAOA,IAAIC,IAAzB,CAA3B,CAAtC;AACD;AACD,eAAK,MAAMC,EAAX,IAAiBhD,qBAAqBiD,eAArB,CAAqC,IAArC,CAAjB,EAA6D;AAC3D,gBAAID,GAAGE,IAAH,GAAUrD,GAAV,CAAc,UAAd,CAAJ,EAA+B;AAC7B+C,6BAAeC,WAAf,CAA2B,CAACG,GAAGE,IAAH,GAAUC,GAAV,CAAc,UAAd,EAA0BJ,IAA3B,CAA3B;AACD;AACF;AACF;;AAED;AACAK,iCAAyB;AACvB,gBAAMxE,QAAQ,KAAK4C,OAAL,KAAiBqD,SAAjB,GAA6B,KAAKrD,OAAL,CAAa,KAAKC,UAAlB,CAA7B,GAA6DoD,SAA3E;;AAEA,iBAAO,CAAC,KAAKrD,OAAN,EAAe,KAAKC,UAApB,EAAgC7C,KAAhC,CAAP;AACD;;AAEDkG,qBAAaC,QAAb,EAAuBxC,IAAvB,EAA6B;AAC3B,gBAAMyC,SAAShF,qBAAqBiD,eAArB,CAAqC,IAArC,CAAf;AACAgC,4BAAkBC,oBAAlB,CAAuCF,MAAvC,EAA+CD,QAA/C,EAAyD,IAAzD,EAA+DxC,IAA/D;AACD;;AAEDnB,eAAO;AACL,cAAI,KAAKiC,QAAL,EAAJ,EAAqB,OAAO,QAAP;AACrB,iBAAO,KAAKvB,KAAZ;AACD;;AAEDqD,6BAAqB;AACnB,iBAAO,KAAKrD,KAAL,KAAe,QAAf,IAA2B,CAAC,KAAKuB,QAAL,EAAnC;AACD;AACDC,6BAAqB;AACnB,iBAAO,KAAKxB,KAAL,KAAe,QAAf,IAA2B,KAAKuB,QAAL,EAAlC;AACD;AACD+B,4BAAoB;AAClB,iBAAO,KAAKtD,KAAL,KAAe,OAAtB;AACD;AACDuB,mBAAW;AACT,iBAAO,KAAK7B,OAAL,KAAiB6D,IAAxB;AACD;;AAED7C,mBAAW;AACT,iBAAO,KAAKN,KAAZ;AACD;;AAEDoD,kBAAU;AACR,gBAAM,CAAC9D,OAAD,EAAUC,UAAV,IAAwB,KAAK2B,sBAAL,EAA9B;;AAEA,cAAI,KAAKE,kBAAL,EAAJ,EAA+B;AAC7B,mBAAO7B,WAAW8D,QAAX,EAAP;AACD;AACD,iBAAO,CAAC/D,UAAUA,QAAQK,WAAR,CAAoB2D,IAA9B,GAAqC,EAAtC,IAA4C,GAA5C,GAAkD/D,UAAzD;AACD;;AAEDgE,qCAA6B;AAC3B,gBAAM,CAACjE,OAAD,EAAUC,UAAV,EAAsB7C,KAAtB,IAA+B,KAAKwE,sBAAL,EAArC;;AAEA,cAAI,KAAK+B,kBAAL,EAAJ,EAA+B;AAC7B,mBAAO;AACLO,sBAAQlE,OADH;AAELmE,wBAAUlE,UAFL;AAGL7C;AAHK,aAAP;AAKD;;AAED,cAAI,KAAK0E,kBAAL,EAAJ,EAA+B;AAC7B,mBAAO;AACLkC,oBAAM/D,UADD;AAEL7C;AAFK,aAAP;AAID;;AAED,cAAI,KAAKwG,iBAAL,EAAJ,EAA8B;AAC5B,mBAAO;AACLQ,qBAAOpE,OADF;AAELgE,oBAAM/D,UAFD;AAGL7C;AAHK,aAAP;AAKD;;AAED,gBAAM,IAAIJ,KAAJ,CAAU,mDAAV,CAAN;AACD;;AAvLc;AA0LjB;;;;;;;;AA1LM8C,qD;;;;;;;AA4LC,YAAMuE,gBAAN,CAAuB;;AAE5BhE,sBAAc;AACZ,eAAKiE,wBAAL,GAAgC,EAAhC;AACA,eAAKC,6BAAL,GAAqC1J,EAAE2J,QAAF,CAAW,KAAKC,mBAAhB,EAAqC,GAArC,CAArC;AACA,eAAKC,YAAL,GAAoB,IAAIvH,GAAJ,EAApB;AACD;AACD;AACA,cAAMwH,0BAAN,CAAiCC,GAAjC,EAAsC5E,OAAtC,EAA+C6E,eAA/C,EAAgE;AAC9D,gBAAMC,WAAW,YAAY;AAC3B,gBAAI9E,YAAY,CAACA,QAAQ+E,KAAT,IAAkB/E,QAAQ+E,KAAR,EAA9B,CAAJ,EAAoD;AAClDF,+BAAiB,MAAM,KAAKG,2BAAL,CAAiCJ,GAAjC,CAAvB;AACA,qBAAO,IAAP;AACD;AACD,mBAAO,KAAP;AACD,WAND;AAOA,eAAKN,wBAAL,CAA8BtF,IAA9B,CAAmC,EAAE8F,QAAF,EAAYF,GAAZ,EAAnC;;AAEAC,2BAAiB,MAAM,KAAKG,2BAAL,CAAiCJ,GAAjC,CAAvB;AACD;;AAEDK,yBAAiBzD,EAAjB,EAAqB;AACnB,gBAAM0D,SAAS,EAAf;AACA,eAAK,MAAMpH,UAAX,IAAyBU,qBAAqB2G,eAArB,CAAqC3D,EAArC,CAAzB,EAAmE;AACjE,iBAAK,MAAMT,IAAX,IAAmBjD,WAAWkD,QAAX,EAAnB,EAA0C;AACxCkE,qBAAOlG,IAAP,CAAY,EAAE+B,IAAF,EAAQjD,YAAYA,WAAWoB,MAAX,EAApB,EAAyCsC,EAAzC,EAAZ;AACD;AACF;AACD,iBAAO0D,MAAP;AACD;;AAED;;AAEA;AACA,cAAME,UAAN,CAAiBR,GAAjB,EAAsBS,OAAtB,EAA+BC,OAA/B,EAAwC;AACtC,cAAI;AACF,kBAAMC,cAAc,KAAKC,gBAAL,CAAsBH,OAAtB,EAA+BC,OAA/B,CAApB;AACA,iBAAK,MAAM9D,EAAX,IAAiBhD,qBAAqBiH,YAArB,CAAkCb,GAAlC,CAAjB,EAAyD;AACvD,oBAAMrB,WAAW/B,GAAGE,IAAH,GAAUC,GAAV,CAAc,UAAd,CAAjB;AACA,mBAAK+D,aAAL,CAAmBH,WAAnB,EAAgChC,QAAhC;AACD;AACD,iBAAK,MAAMxC,IAAX,IAAmB,MAAM,KAAK4E,cAAL,CAAoBf,GAApB,CAAzB,EAAmD;AACjD7D,mBAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAa;AACpC,qBAAK,MAAMoC,QAAX,IAAuBpC,SAAvB,EAAkC;AAChC,uBAAKuE,aAAL,CAAmBH,WAAnB,EAAgChC,QAAhC;AACD;AACF,eAJD;AAKD;AACF,WAbD,CAaE,OAAOhG,CAAP,EAAU;AACVC,oBAAQC,KAAR,CAAcF,CAAd;AACD;AACF;;AAEDmI,sBAAcH,WAAd,EAA2BhC,QAA3B,EAAqC;AACnC,cAAI,CAACzI,IAAD,EAAO8K,WAAP,IAAsBL,YAAYhC,SAASsC,KAAT,CAAeC,IAA3B,CAA1B;;AAEA,cAAIhL,SAAS,CAAC,CAAd,EAAiB;AACfyI,qBAASsC,KAAT,CAAeC,IAAf,GAAsB,CAAtB;AACD,WAFD,MAEO;AACLvC,qBAASsC,KAAT,CAAeC,IAAf,GAAsBhL,IAAtB;AACD;;AAED,cAAI,CAACiL,KAAD,EAAQC,YAAR,IAAwBT,YAAYhC,SAAS0C,GAAT,CAAaH,IAAzB,CAA5B;;AAEA,cAAIC,UAAU,CAAC,CAAf,EAAkB;AAChBxC,qBAAS0C,GAAT,CAAaH,IAAb,GAAoB,CAApB;AACD,WAFD,MAEO;AACLvC,qBAAS0C,GAAT,CAAaH,IAAb,GAAoBC,KAApB;AACD;AACD,cAAIH,eAAeI,YAAnB,EAAiC;AAC/BpL,mBAAOsL,MAAP,CAAc,+EAAd;AACA;AACD;AACF;;AAEDV,yBAAiBH,OAAjB,EAA0BC,OAA1B,EAAmC;AACjC,gBAAMa,UAAU,EAAhB,CADiC,CACb;AACpB,cAAIC,MAAM,IAAItL,KAAKuL,gBAAT,EAAV;AACA,cAAIC,IAAIF,IAAIG,kBAAJ,CAAuBlB,OAAvB,EAAgCC,OAAhC,CAAR;AACA,cAAIkB,YAAYF,EAAEG,MAAlB;AACA,cAAIC,YAAYJ,EAAEK,MAAlB;AACA,cAAIC,YAAYN,EAAEM,SAAlB;AACA,cAAIC,QAAQT,IAAIU,SAAJ,CAAcN,SAAd,EAAyBE,SAAzB,EAAoC,KAApC,CAAZ;;AAEA,cAAIK,eAAe,CAAnB;AACA,cAAIC,UAAU,CAAd;AACA,cAAIC,kBAAkB,CAAtB;AACA,cAAIC,kBAAkB,CAAtB;AACA,eAAK,IAAI,CAACtH,IAAD,EAAOuH,IAAP,CAAT,IAAyBN,KAAzB,EAAgC;AAC9B,gBAAIjH,SAAS,CAAb,EAAgB;AACdqH,gCAAkB,CAAlB;AACAC,gCAAkB,CAAlB;AACA,mBAAK,IAAIE,IAAI,CAAb,EAAgBA,IAAID,KAAK7H,MAAzB,EAAiC8H,GAAjC,EAAsC;AACpCjB,wBAAQY,YAAR,IAAwB,CAACC,OAAD,EAAU,KAAV,CAAxB;AACAD;AACAC;AACD;AACF,aARD,MAQO,IAAIpH,SAAS,CAAb,EAAgB;AACrB,kBAAIqH,kBAAkB,CAAtB,EAAyB;AACvB,sBAAMI,gBAAgBC,KAAKC,GAAL,CAASN,eAAT,EAA0BE,KAAK7H,MAA/B,CAAtB;AACA,qBAAK,IAAI8H,IAAI,CAAb,EAAgBA,IAAIC,aAApB,EAAmCD,GAAnC,EAAwC;AACtCjB,0BAAQY,eAAeM,aAAf,GAA+BD,CAAvC,IAA4C,CAACJ,OAAD,EAAU,IAAV,CAA5C;AACAA;AACD;AACDG,uBAAOA,KAAKK,SAAL,CAAeH,aAAf,CAAP;AACD;AACD,kBAAIF,KAAK7H,MAAL,GAAc,CAAlB,EAAqB;AACnB0H,2BAAWG,KAAK7H,MAAhB;AACA4H,mCAAmBC,KAAK7H,MAAxB;AACD;AACF,aAbM,MAaA;AACL,kBAAI4H,kBAAkB,CAAtB,EAAyB;AACvB,sBAAMG,gBAAgBC,KAAKC,GAAL,CAASL,eAAT,EAA0BC,KAAK7H,MAA/B,CAAtB;AACA,qBAAK,IAAI8H,IAAI,CAAb,EAAgBA,IAAIC,aAApB,EAAmCD,GAAnC,EAAwC;AACtCjB,0BAAQY,YAAR,IAAwB,CAACC,UAAUK,aAAV,GAA0BD,CAA3B,EAA8B,IAA9B,CAAxB;AACAL;AACD;AACDI,uBAAOA,KAAKK,SAAL,CAAeH,aAAf,CAAP;AACD;AACDJ,iCAAmBE,KAAK7H,MAAxB;AACA,mBAAK,IAAI8H,IAAI,CAAb,EAAgBA,IAAID,KAAK7H,MAAzB,EAAiC8H,GAAjC,EAAsC;AACpCjB,wBAAQY,YAAR,IAAwB,CAAC,CAAC,CAAF,EAAK,KAAL,CAAxB;AACAA;AACD;AACF;AACF;;AAEDX,cAAIqB,kBAAJ,CAAuBZ,KAAvB,EAA8BD,SAA9B;;AAEA,iBAAOT,OAAP;AACD;AACD;AACA9E,oBAAYqG,KAAZ,EAAmB;AACjB,cAAI,CAACA,KAAL,EAAY;AACZA,gBAAMnJ,OAAN,CAAcgD,QAAQ;AACpB,gBAAGA,IAAH,EAAS;AACP,mBAAKmD,YAAL,CAAkB3G,GAAlB,CAAsBwD,IAAtB;AACD;AACF,WAJD;AAKA,eAAKgD,6BAAL;AACD;;AAED,cAAME,mBAAN,GAA4B;AAC1B,eAAK,IAAI2C,IAAI,CAAb,EAAgBA,IAAI,KAAK9C,wBAAL,CAA8BhF,MAAlD,EAA0D8H,GAA1D,EAA+D;AAC7D,gBAAI,CAAC,CAAC,GAAG,KAAK1C,YAAT,EAAuBiD,IAAvB,CAA4BpG,QAAQA,KAAKqG,QAAL,CAAc,KAAKtD,wBAAL,CAA8B8C,CAA9B,EAAiCxC,GAA/C,CAApC,CAAL,EAA+F;AAC/F,gBAAI,EAAE,MAAM,KAAKN,wBAAL,CAA8B8C,CAA9B,EAAiCtC,QAAjC,EAAR,CAAJ,EAA0D;AACxD,mBAAKR,wBAAL,CAA8BjF,MAA9B,CAAqC+H,CAArC,EAAwC,CAAxC;AACAA;AACD;AACF;AACD,eAAK1C,YAAL,GAAoB,IAAIvH,GAAJ,EAApB;AACD;;AAED,cAAM6H,2BAAN,CAAkCJ,GAAlC,EAAuC;AACrC,cAAIM,SAAS,EAAb;AACA,eAAK,MAAM1D,EAAX,IAAiBhD,qBAAqBiH,YAArB,CAAkCb,GAAlC,CAAjB,EAAyD;AACvDM,qBAASA,OAAO2C,MAAP,CAAc,KAAK5C,gBAAL,CAAsBzD,EAAtB,CAAd,CAAT;AACD;AACD,eAAK,MAAMT,IAAX,IAAmB,MAAM,KAAK4E,cAAL,CAAoBf,GAApB,CAAzB,EAAmD;AACjD,iBAAI,MAAM9G,UAAV,IAAwBiD,KAAK+G,eAAL,EAAxB,EAAgD;AAC9C,mBAAK,MAAMtG,EAAX,IAAiBhD,qBAAqBiD,eAArB,CAAqC3D,UAArC,CAAjB,EAAmE;AACjE,sBAAMyF,WAAW/B,GAAGE,IAAH,GAAUC,GAAV,CAAc,UAAd,EAA0BJ,IAA3C;AACA;AACA,oBAAI,CAACgC,SAASqE,QAAT,CAAkBhD,GAAlB,CAAL,EAA6B;AAC3BM,yBAAOlG,IAAP,CAAY,EAAE+B,IAAF,EAAQjD,YAAYA,WAAWoB,MAAX,EAApB,EAAyCsC,EAAzC,EAAZ;AACD;AACF;AACF;AACF;AACD,iBAAO0D,MAAP;AACD;;AAED,cAAMS,cAAN,CAAqBf,GAArB,EAA0B;AACxB,gBAAMmD,WAAW7H,mCAAmC8H,SAAnC,GAA+CC,OAA/C,CAAuDC,OAAOA,IAAIlH,QAAJ,EAA9D,CAAjB;AACA,gBAAMmH,qBAAqB,MAAMC,QAAQnK,GAAR,CAAY8J,SAASvI,GAAT,CAAauB,QAAQ;AAChE,mBAAOA,KAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAa;AAC3C,qBAAO,EAAEJ,IAAF,EAAQI,SAAR,EAAP;AACD,aAFM,CAAP;AAGD,WAJ4C,CAAZ,CAAjC;AAKA,iBAAOgH,mBAAmB/J,MAAnB,CAA0B,CAAC,EAAE2C,IAAF,EAAQI,SAAR,EAAD,KAAyB;AACxD,kBAAMoC,WAAWpC,UAAUkH,IAAV,CAAe/G,OAAOA,OAAOA,IAAIC,IAAjC,CAAjB;AACA,mBAAOgC,YAAYA,SAAShC,IAAT,CAAcqG,QAAd,CAAuBhD,GAAvB,CAAnB;AACD,WAHM,EAGJpF,GAHI,CAGA,CAAC,EAAEuB,IAAF,EAAQI,SAAR,EAAD,KAAyBJ,IAHzB,CAAP;AAID;;AAvL2B;;;;;;;;;;sCAAjBsD,iD;;;;;;;;AA2Lb,qBAAe9H,YAAf,CAA4BW,YAA5B,EAA0CsG,MAA1C,EAAkD,CAAE;;AAE7C,YAAMpC,iBAAiB,IAAIiD,gBAAJ,EAAvB;;;;;;;;;;oCAAMjD,+C;;;;;;;;AAEb,YAAM5C,uBAAuB;AAC3B8J,uBAAe,IAAI7N,qBAAJ,EADY;AAE3B8N,qBAAa,IAAInG,GAAJ,EAFc;;AAI3B1D,kBAAUwJ,GAAV,EAAe5L,KAAf,EAAsB;AACpB,cAAG,KAAKgM,aAAL,CAAmBjK,GAAnB,CAAuB6J,GAAvB,EAA4B5L,KAA5B,CAAH,EAAuC;AACvC,gBAAMiH,WAAWjH,MAAMoF,IAAN,GAAaC,GAAb,CAAiB,UAAjB,CAAjB;AACA,cAAI4B,YAAYA,SAAShC,IAAzB,EAA+B;AAC7BH,2BAAeC,WAAf,CAA2B,CAACkC,SAAShC,IAAV,CAA3B;AACA,iBAAKgH,WAAL,CAAiBpI,WAAjB,CAA6BoD,SAAShC,IAAtC,EAA4C,MAAM,IAAIpE,GAAJ,EAAlD,EAA6DY,GAA7D,CAAiEzB,KAAjE;AACD;AACD,eAAKgM,aAAL,CAAmB5J,SAAnB,CAA6BwJ,GAA7B,EAAkC5L,KAAlC;AACA4L,cAAIvH,cAAJ;;AAEA;AACA,eAAK,MAAMI,IAAX,IAAmBmH,IAAIlH,QAAJ,EAAnB,EAAmC;AACjCD,iBAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAaC,eAAeC,WAAf,CAA2BF,UAAU3B,GAAV,CAAc8B,OAAOA,IAAIC,IAAzB,CAA3B,CAAtC;AACD;AACF,SAlB0B;;AAoB3B9C,qBAAayJ,GAAb,EAAkB5L,KAAlB,EAAyB;AACvB,eAAKgM,aAAL,CAAmBE,MAAnB,CAA0BN,GAA1B,EAA+B5L,KAA/B;AACA4L,cAAIvH,cAAJ;AACA,eAAK,MAAMI,IAAX,IAAmBmH,IAAIlH,QAAJ,EAAnB,EAAmC;AACjCD,iBAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAaC,eAAeC,WAAf,CAA2BF,UAAU3B,GAAV,CAAc8B,OAAOA,IAAIC,IAAzB,CAA3B,CAAtC;AACD;AACD;AACD,SA3B0B;;AA6B3BkH,8BAAsBnM,KAAtB,EAA6B;AAC3B,gBAAMiH,WAAWjH,MAAMoF,IAAN,GAAaC,GAAb,CAAiB,UAAjB,CAAjB;AACA,cAAI4B,YAAYA,SAAShC,IAAzB,EAA+B;AAC7BH,2BAAeC,WAAf,CAA2B,CAACkC,SAAShC,IAAV,CAA3B;AACA,gBAAI,KAAKgH,WAAL,CAAiBlK,GAAjB,CAAqBkF,SAAShC,IAA9B,CAAJ,EAAyC;AACvC,mBAAKgH,WAAL,CAAiB5G,GAAjB,CAAqB4B,SAAShC,IAA9B,EAAoCmH,MAApC,CAA2CpM,KAA3C;AACD;AACF;AACD,gBAAMqM,OAAO,CAAC,GAAG,KAAKxD,eAAL,CAAqB7I,KAArB,CAAJ,CAAb;AACA,eAAKgM,aAAL,CAAmBM,gBAAnB,CAAoCtM,KAApC;AACAqM,eAAKpK,OAAL,CAAa2J,OAAO;AAClBA,gBAAIvH,cAAJ;AACD,WAFD;;AAIA;AACA,eAAK,MAAMuH,GAAX,IAAkBS,IAAlB,EAAwB;AACtB,iBAAK,MAAM5H,IAAX,IAAmBmH,IAAIlH,QAAJ,EAAnB,EAAmC;AACjCD,mBAAKE,YAAL,GAAoBC,IAApB,CAAyBC,aAAaC,eAAeC,WAAf,CAA2BF,UAAU3B,GAAV,CAAc8B,OAAOA,IAAIC,IAAzB,CAA3B,CAAtC;AACD;AACF;AACF,SAjD0B;;AAmD3BkE,qBAAab,GAAb,EAAkB;AAChB,eAAK,MAAM,CAACrB,QAAD,EAAWsF,GAAX,CAAX,IAA8B,KAAKN,WAAL,CAAiBO,OAAjB,EAA9B,EAA0D;AACxD,gBAAIvF,SAASqE,QAAT,CAAkBhD,GAAlB,CAAJ,EAA4B,OAAOiE,GAAP;AAC7B;AACD,iBAAO,EAAP;AACD,SAxD0B;;AA0D3BpH,wBAAgByG,GAAhB,EAAqB;AACnB,cAAI,CAAC,KAAKI,aAAL,CAAmBS,OAAnB,CAA2Bb,GAA3B,CAAL,EAAsC,OAAO,EAAP;AACtC,iBAAO/F,MAAM6G,IAAN,CAAW,KAAKV,aAAL,CAAmBW,YAAnB,CAAgCf,GAAhC,CAAX,CAAP;AACD,SA7D0B;AA8D3B/C,wBAAgB7I,KAAhB,EAAuB;AACrB,cAAI,CAAC,KAAKgM,aAAL,CAAmBY,QAAnB,CAA4B5M,KAA5B,CAAL,EAAyC,OAAO,EAAP;AACzC,iBAAO6F,MAAM6G,IAAN,CAAW,KAAKV,aAAL,CAAmBa,WAAnB,CAA+B7M,KAA/B,CAAX,CAAP;AACD,SAjE0B;;AAmE3BsE,wBAAgBsH,GAAhB,EAAqB;AACnB,iBAAO,KAAKzG,eAAL,CAAqByG,GAArB,EAA0B5I,MAA1B,IAAoC,CAA3C;AACD,SArE0B;AAsE3B8J,wBAAgB9M,KAAhB,EAAuB;AACrB,iBAAO,KAAK6I,eAAL,CAAqB7I,KAArB,EAA4BgD,MAA5B,IAAsC,CAA7C;AACD,SAxE0B;;AA0E3B;;;AAGA+J,gBAAQ;AACN,eAAKf,aAAL,CAAmBe,KAAnB;AACA,eAAKf,aAAL,CAAmBgB,UAAnB,GAAgC/K,OAAhC,CAAwC2J,OAAOA,IAAIvH,cAAJ,EAA/C;AACD;AAhF0B,OAA7B;;;;;;;;AAAMnC,+D;;;;;;;AAmFC,YAAM4B,aAAN,CAAoB;AACzBC,oBAAYL,OAAZ,EAAqBC,UAArB,EAAiC;AAC/B,eAAKD,OAAL,GAAeA,OAAf;AACA,eAAKC,UAAL,GAAkBA,UAAlB;AACD;;AAEDsJ,wBAAgB;AACd,iBAAOrJ,mCAAmCyB,GAAnC,CAAuC,KAAK3B,OAA5C,EAAqD,KAAKC,UAA1D,CAAP;AACD;;AAEDuJ,eAAOC,KAAP,EAAc;AACZ,cAAGA,MAAMzJ,OAAN,KAAkB,KAAKA,OAA1B,EAAmC;AACjC;AACA,gBAAGmC,MAAMuH,OAAN,CAAc,KAAK1J,OAAnB,CAAH,EAAgC;AAC9B,kBAAG,OAAO,KAAKC,UAAZ,KAA2B,OAAOwJ,MAAMxJ,UAA3C,EAAuD;AACrD,oBAAG,OAAO,KAAKA,UAAZ,KAA2B,QAA9B,EAAwC;AACtC,yBAAO,KAAKA,UAAL,KAAqBwJ,MAAMxJ,UAAN,GAAmB,EAA/C;AACD;AACD,oBAAG,OAAOwJ,MAAMxJ,UAAb,KAA4B,QAA/B,EAAyC;AACvC,yBAAOwJ,MAAMxJ,UAAN,KAAsB,KAAKA,UAAL,GAAkB,EAA/C;AACD;AACF;AACF;AACD,mBAAOwJ,MAAMxJ,UAAN,KAAqB,KAAKA,UAAjC;AACD;AACD,iBAAO,KAAP;AACD;;AAED0J,4BAAoB;AAClB,cAAG,CAAC,KAAKvK,cAAT,EAAyB;AACvB,mBAAO,IAAP;AACD,WAFD,MAEO;AACL,iBAAKA,cAAL,GAAsB,KAAKA,cAAL,CAAoBuK,iBAApB,EAAtB;AACD;AACD,iBAAO,KAAKvK,cAAZ;AACD;;AAEDwK,mBAAW;AACT,cAAG,KAAK5J,OAAL,YAAwBoC,GAA3B,EAAgC;AAC9B,mBAAO,KAAKpC,OAAL,CAAa2B,GAAb,CAAiB,KAAK1B,UAAtB,CAAP;AACD,WAFD,MAEO,IAAI,KAAKD,OAAL,YAAwB7C,GAA5B,EAAiC;AACtC,mBAAO,CAAC,GAAG,KAAK6C,OAAT,EAAkB,KAAK6J,SAAvB,CAAP;AACD,WAFM,MAEA;AACL,mBAAO,KAAK7J,OAAL,CAAa,KAAKC,UAAlB,CAAP;AACD;AACF;AA7CwB;;AAgD3B;;;;;;;;;;mCAhDaG,8C;;;;;;;;AAiDb,YAAMF,qCAAqC,IAAIxF,UAAJ,EAA3C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;AArBMwF,6E;;;;;;;AAsBN,YAAM4J,mCAAmC,IAAIC,OAAJ,EAAzC,C,CAAwD;AACxD;AACA;;;;;;;AAFMD,2E;;;;;;;AAGN,YAAME,iCAAiC,IAAI5H,GAAJ,EAAvC,C,CAAkD;AAClD;AACA;;;;;;;AAFM4H,yE;;;;;;;AAGN,YAAMC,oCAAoC,IAAIF,OAAJ,EAA1C,C,CAAyD;AACzD;AACA;;;;;;;AAFME,4E;;;;;;;AAGN,YAAMC,8BAA8B,IAAIH,OAAJ,EAApC,C,CAAmD;;;;;;;;AAA7CG,sE;;;;;;;AAEN,YAAMC,IAAN,CAAW;AACT9J,sBAAc;AACZ,eAAKnD,YAAL,GAAoB,IAAIC,GAAJ,EAApB;AACA,eAAKiN,SAAL,GAAiB,KAAjB;AACA,eAAKjJ,SAAL,GAAiB,EAAjB;AACD;;AAEDkJ,oBAAY9G,QAAZ,EAAsB;AACpB,cAAI,CAACA,QAAL,EAAe;AACf,cAAI,CAAC,KAAKpC,SAAL,CAAewG,IAAf,CAAoBrG,OAAOzG,EAAEgF,OAAF,CAAUyB,GAAV,EAAeiC,QAAf,CAA3B,CAAL,EAA2D;AACzD,iBAAKpC,SAAL,CAAenC,IAAf,CAAoBuE,QAApB;AACD;AACD;AACD;;AAEDuE,0BAAkB;AAChB,iBAAO,KAAK5K,YAAZ;AACD;;AAEDgG,sBAAcpF,UAAd,EAA0B;AACxB,eAAKZ,YAAL,CAAkBa,GAAlB,CAAsBD,UAAtB;AACD;;AAEDsF,yBAAiBtF,UAAjB,EAA6B;AAC3B,eAAKZ,YAAL,CAAkBwL,MAAlB,CAAyB5K,UAAzB;AACD;;AAED,cAAMmD,YAAN,GAAqB;AACnB,eAAKE,SAAL,GAAiB,MAAMiH,QAAQnK,GAAR,CAAY,KAAKkD,SAAjB,CAAvB;AACA,eAAKA,SAAL,GAAiB,KAAKA,SAAL,CAAe/C,MAAf,CAAsBkM,KAAKA,CAA3B,CAAjB;AACA,eAAKnJ,SAAL,GAAiBtG,EAAE0P,QAAF,CAAW,KAAKpJ,SAAhB,EAA2BtG,EAAEgF,OAA7B,CAAjB;AACA,iBAAO,KAAKsB,SAAZ;AACD;;AAEDqJ,4BAAoB;AAClB,iBAAO,cAAP;AACD;;AAEDC,2BAAmBlH,QAAnB,EAA6B;AAC3B,gBAAMjC,MAAMiC,YAAYmH,eAAeC,wBAAf,EAAxB;AACA,eAAKN,WAAL,CAAiB/I,GAAjB;;AAEA,eAAKL,YAAL,GAAoBC,IAApB,CAAyBC,aAAaC,eAAeC,WAAf,CAA2BF,UAAU3B,GAAV,CAAc8B,OAAOA,IAAIC,IAAzB,CAA3B,CAAtC;AACA,eAAI,MAAM2G,GAAV,IAAiB,CAAC,GAAG,KAAKhL,YAAT,CAAjB,EAAyC;AACvC,iBAAK,MAAMsE,EAAX,IAAiBhD,qBAAqBiD,eAArB,CAAqCyG,GAArC,CAAjB,EAA4D;AAC1D,kBAAI1G,GAAGE,IAAH,GAAUrD,GAAV,CAAc,UAAd,CAAJ,EAA+B;AAC7B+C,+BAAeC,WAAf,CAA2B,CAACG,GAAGE,IAAH,GAAUC,GAAV,CAAc,UAAd,EAA0BJ,IAA3B,CAA3B;AACD;AACF;AACD2G,gBAAI5E,YAAJ,CAAiBhC,GAAjB,EAAsB,IAAtB;AACD;AACF;AAnDQ;;;;;;;;AAAL6I,+C;;;;;;;AAsDN,YAAMnI,cAAN,SAA6BmI,IAA7B,CAAkC;;AAEhCK,4BAAoB;AAClB,iBAAO,qBAAqB,KAAKxK,OAA1B,GAAoC,GAApC,GAA0C,KAAKC,UAAtD;AACD;;AAEDI,oBAAYL,OAAZ,EAAqBC,UAArB,EAAiC;AAC/B;;AAEA,eAAKD,OAAL,GAAeA,OAAf;AACA,eAAKC,UAAL,GAAkBA,UAAlB;AACD;;AAED2K,kBAAU,CAAE;AACZC,oBAAY,CAAE;AAdkB;;;;;;;;AAA5B7I,yD;;;;;;;AAiBN,YAAMK,iBAAN,SAAgC8H,IAAhC,CAAqC;AACnC,eAAO7H,2BAAP,CAAmCJ,aAAnC,EAAkD;AAChD,iBAAO4H,iCAAiC3J,WAAjC,CAA6C+B,aAA7C,EAA4D,MAAM,IAAIG,iBAAJ,CAAsBH,aAAtB,CAAlE,CAAP;AACD;AACD7B,oBAAY6B,aAAZ,EAA2B;AACzB;AACA,eAAK4I,iBAAL,CAAuB5I,aAAvB;;AAEA;AACA;AACA;AACA;AACA;AACD;;AAED6I,gCAAwBC,GAAxB,EAA6B;AAC3B,gBAAMC,QAAQD,IAAI3K,WAAJ,CAAgB6K,SAA9B;;AAEA,gBAAMC,cAAcC,OAAOC,yBAAP,CAAiCJ,KAAjC,CAApB;AACA,iBAAOG,OAAOtC,OAAP,CAAeqC,WAAf,EAA4B3L,GAA5B,CAAgC,CAAC,CAAC8L,GAAD,EAAMC,IAAN,CAAD,MAAkBA,KAAKD,GAAL,GAAWA,GAAX,EAAgBC,IAAlC,CAAhC,CAAP;AACD;;AAEDC,qBAAaR,GAAb,EAAkBS,UAAlB,EAA8BC,KAA9B,EAAqC;AACnCN,iBAAOO,cAAP,CAAsBX,GAAtB,EAA2BS,WAAWH,GAAtC,EAA2CF,OAAOQ,MAAP,CAAc,EAAd,EAAkBH,UAAlB,EAA8B;AACvErO,kBAAM,GAAGyO,IAAT,EAAe;AACb,kBAAI;AACF,uBAAOJ,WAAWrO,KAAX,CAAiB0O,KAAjB,CAAuB,IAAvB,EAA6BD,IAA7B,CAAP;AACD,eAFD,SAEU;AACRH,sBAAMK,IAAN,CAAW,IAAX,EAAiB,GAAGF,IAApB;AACD;AACF;AAPsE,WAA9B,CAA3C;AASD;;AAEDf,0BAAkBE,GAAlB,EAAuB;AACrB,gBAAMgB,SAAS,IAAf;AACA,gBAAMC,uBAAuB,KAAKlB,uBAAL,CAA6BC,GAA7B,CAA7B;AACAI,iBAAOtC,OAAP,CAAesC,OAAOC,yBAAP,CAAiCL,GAAjC,CAAf,EAHqB,CAGkC;;AAEvD;AACA;AACA,gBAAMkB,wBAAwB,IAAI/O,GAAJ,CAAQ,CAAC,IAAD,EAAO,KAAP,EAAc,aAAd,EAA6B,QAA7B,EAAuC,SAAvC,EAAkD,OAAlD,EAA2D,QAA3D,EAAqE,MAArE,EAA6E,WAA7E,EAA0F,SAA1F,EAAqG,UAArG,EAAiH,SAAjH,EAA4H,MAA5H,EAAoI,MAApI,EAA4I,aAA5I,EAA2J,QAA3J,EAAqK,aAArK,EAAoL,OAApL,EAA6L,UAA7L,EAAyM,gBAAzM,EAA2N,QAA3N,CAAR,CAA9B;;AAEA8O,+BACG7N,MADH,CACUqN,cAAc,CAACS,sBAAsB7N,GAAtB,CAA0BoN,WAAWH,GAArC,CADzB,EAEG/M,OAFH,CAEW4N,iBAAiB;AAC1B;AACA,gBAAIA,cAAc/O,KAAlB,EAAyB;AACvB,kBAAIzC,WAAWwR,cAAc/O,KAAzB,CAAJ,EAAqC;AACnC,qBAAKoO,YAAL,CAAkBR,GAAlB,EAAuBmB,aAAvB,EAAsC,YAAY;AAChD;AACA,sBAAIzP,OAAO0P,uBAAX,EAAoC;AAClC;AACD;;AAED,uBANgD,CAM1C;AACNJ,yBAAOvB,kBAAP;AACD,iBARD;AASD,eAVD,MAUO;AACL;AACD;AACF,aAdD,MAcO;AACH;AACD;AACJ,WArBD;AAsBD;;AAEDD,4BAAoB;AAClB,iBAAO,mBAAP;AACD;AArEkC;;;;;;;;AAA/BnI,4D;;;;;;;AAwEN,YAAMG,oBAAN,SAAmC2H,IAAnC,CAAwC;AACtC,eAAO1H,sBAAP,CAA8B0B,QAA9B,EAAwC;AACtC,iBAAO6F,+BAA+B7J,WAA/B,CAA2CgE,QAA3C,EAAqD,MAAM,IAAI3B,oBAAJ,CAAyB2B,QAAzB,CAA3D,CAAP;AACD;;AAED9D,oBAAY8D,QAAZ,EAAsB;AACpB;AACA,eAAKA,QAAL,GAAgBA,QAAhB;AACA,eAAK/G,KAAL,GAAayG,KAAKM,QAAL,CAAb;AACA,gBAAM,EAAEkI,YAAF,EAAgBC,UAAhB,KAA+BlB,OAAOmB,wBAAP,CAAgC1I,IAAhC,EAAsCM,QAAtC,CAArC;;AAEA;AACAiH,iBAAOO,cAAP,CAAsB9H,IAAtB,EAA4BM,QAA5B,EAAsC;AACpCkI,wBADoC;AAEpCC,sBAFoC;;AAIpC3K,iBAAK,MAAM,KAAKvE,KAJoB;AAKpCoP,iBAAKpP,SAAS;AACZ,oBAAM8H,SAAS,KAAK9H,KAAL,GAAaA,KAA5B;AACA,mBAAKqN,kBAAL;AACA,qBAAOvF,MAAP;AACD;AATmC,WAAtC;AAWD;;AAEDsF,4BAAoB;AAClB,iBAAO,2BAA2B,KAAKrG,QAAvC;AACD;AA3BqC;;;;;;;;AAAlC3B,+D;;;;;;;AA8BN,YAAMK,oBAAN,SAAmCsH,IAAnC,CAAwC;AACtC,eAAOrH,qBAAP,CAA6B2J,OAA7B,EAAsC;AACpC,iBAAOxC,kCAAkC9J,WAAlC,CAA8CsM,OAA9C,EAAuD,MAAM,IAAI5J,oBAAJ,CAAyB4J,OAAzB,CAA7D,CAAP;AACD;AACDpM,oBAAYoM,OAAZ,EAAqB;AACnB;;AAEA,eAAKC,QAAL,GAAgBD,OAAhB;;AAEA,gBAAME,IAAI,IAAIC,gBAAJ,CAAqB,CAACC,SAAD,EAAYC,QAAZ,KAAyB;AACtD;AACA;AACA;AACA;AACA,iBAAKC,cAAL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACD,WA1BS,CAAV;;AA4BAJ,YAAEK,OAAF,CAAU,KAAKN,QAAf,EAAyB;AACvBO,wBAAY,IADW;AAEvBC,6BAAiB7J,SAFM;AAGvB8J,+BAAmB,IAHI;;AAKvBC,2BAAe,IALQ;AAMvBC,mCAAuB,IANA;;AAQvBC,uBAAW,IARY;;AAUvBC,qBAAS;AAVc,WAAzB;;AAaA;AACD;;AAEDR,yBAAiB;AACf,eAAKtC,kBAAL;AACD;;AAEDD,4BAAoB;AAClB,iBAAO,2BAA2B,KAAKkC,QAAvC;AACD;AA3DqC;;;;;;;;AAAlC7J,+D;;;;;;;AA8DN,YAAME,cAAN,SAA6BoH,IAA7B,CAAkC;AAChC,eAAOrH,qBAAP,CAA6B2J,OAA7B,EAAsC;AACpC,iBAAOvC,4BAA4B/J,WAA5B,CAAwCsM,OAAxC,EAAiD,MAAM,IAAI1J,cAAJ,CAAmB0J,OAAnB,CAAvD,CAAP;AACD;;AAEDpM,oBAAYoM,OAAZ,EAAqB;AACnB;;AAEA,eAAKC,QAAL,GAAgBD,OAAhB;;AAEA;AACA,cAAI,KAAKC,QAAL,CAAc/J,OAAd,KAA0B,OAA1B,IAAqC,KAAK+J,QAAL,CAAc/J,OAAd,KAA0B,UAAnE,EAA+E;AAC7E,iBAAK+J,QAAL,CAAcc,gBAAd,CAA+B,OAA/B,EAAwC,MAAM;AAC5C,mBAAKT,cAAL;AACD,aAFD;AAGD,WAJD,MAIO,IAAI,KAAKL,QAAL,CAAc/J,OAAd,KAA0B,oBAA9B,EAAoD;AACzD,iBAAK+J,QAAL,CAAce,MAAd,CAAqBC,EAArB,CAAwB,SAAxB,EAAmC,MAAM;AACvC,mBAAKX,cAAL;AACD,aAFD;AAGD;AACF;;AAEDA,yBAAiB;AACf,eAAKtC,kBAAL;AACD;;AAEDD,4BAAoB;AAClB,iBAAO,qBAAqB,KAAKkC,QAAjC;AACD;AA5B+B;;;;;;;;AAA5B3J,yD;;;;;;;AA+BN,YAAMC,cAAN,SAA6BmH,IAA7B,CAAkC;AAChC,mBAAWlH,QAAX,GAAsB;AACpB,cAAI,CAAC,KAAK0K,SAAV,EAAqB;AACnB,iBAAKA,SAAL,GAAiB,IAAI3K,cAAJ,EAAjB;AACA;AACA,iBAAK2K,SAAL,CAAeC,YAAf;AACD;AACD,iBAAO,KAAKD,SAAZ;AACD;;AAEDC,uBAAe;AACb,cAAIC,IAAI,CAAR;AACA;AACA,cAAIrM,KAAKnH,gBAAgBiC,KAAhB,CAAsB,MAAMuR,GAA5B,CAAT;AACArM,aAAGsM,MAAH,CAAU,IAAV;AACAtM,aAAGuM,QAAH,CAAY,MAAM;AAChB,iBAAKhB,cAAL;AACD,WAFD;AAGD;;AAEDA,yBAAiB;AACf,eAAKtC,kBAAL;AACD;;AAEDD,4BAAoB;AAClB,iBAAO,gBAAP;AACD;AA1B+B;;;;;;;;AAA5BxH,yD;;;;;;;AA6BC,YAAMgL,yBAAN,SAAwC5T,oBAAxC,CAA6D;AAClEiG,oBAAY4N,IAAZ,EAAkB,GAAGpC,IAArB,EAA2B;AACzB,gBAAMoC,IAAN,EAAY,GAAGpC,IAAf;AACA,eAAKnK,IAAL,CAAU,EAAEwM,UAAU,WAAZ,EAAV;AACA,eAAKC,kBAAL;AACD;;AAEDC,kBAAU;AACR,gBAAMA,OAAN;AACA3K,4BAAkB4K,gBAAlB,CAAmC,IAAnC;AACD;;AAED;AACAC,kBAAU;AACR,iBAAO,IAAP;AACD;;AAEDH,6BAAqB;AACnB,cAAI,KAAKI,UAAL,EAAJ,EAAuB;AACrB;AACD;;AAED3R,6BAAmBC,uBAAnB,CAA2C,IAA3C;AACD;AACD2R,+BAAuB;AACrB,iBAAO,IAAP;AACD;;AAEDtR,uBAAe;AACb,iBAAO,IAAIuR,aAAJ,CAAkB,IAAlB,CAAP;AACD;;AAEDC,+BAAuBC,UAAvB,EAAmC;AACjC,gBAAMC,kBAAkB,KAAK1R,YAAL,GAAoBe,GAApB,EAAxB;AACA,gBAAM4Q,oBAAoBF,WAAWzR,YAAX,GAA0Be,GAA1B,EAA1B;AACA,gBAAM,CAAC6Q,GAAD,EAAMC,MAAN,EAActF,KAAd,IAAuBmF,gBAAgBI,WAAhB,CAA4BH,iBAA5B,CAA7B;AACA,iBAAOE,MAAP;AACD;AArCiE;;;;;;;;;;+CAAvDf,0D;;;;;;;;AAwCb,YAAMS,aAAN,CAAoB;AAClBpO,oBAAY/D,KAAZ,EAAmB;AACjB,eAAK2S,MAAL,GAAc3S,KAAd;AACD;;AAEDwL,0BAAkB;AAChB,iBAAOtJ,qBAAqB2G,eAArB,CAAqC,KAAK8J,MAA1C,CAAP;AACD;;AAEDhR,cAAM;AACJ,iBAAOkE,MAAM6G,IAAN,CAAW,KAAKlB,eAAL,EAAX,CAAP;AACD;;AAEDoH,iBAAS;AACP,iBAAO,KAAKpH,eAAL,GAAuB1J,MAAvB,CAA8BN,cAAcA,WAAW8F,iBAAX,EAA5C,EAA4EpE,GAA5E,CAAgF1B,cAAcA,WAAWmG,0BAAX,EAA9F,CAAP;AACD;;AAEDkL,kBAAU;AACR,iBAAO,KAAKrH,eAAL,GAAuB1J,MAAvB,CAA8BN,cAAcA,WAAW6F,kBAAX,EAA5C,EAA6EnE,GAA7E,CAAiF1B,cAAcA,WAAWmG,0BAAX,EAA/F,CAAP;AACD;;AAEDmL,kBAAU;AACR,iBAAO,KAAKtH,eAAL,GAAuB1J,MAAvB,CAA8BN,cAAcA,WAAWgE,kBAAX,EAA5C,EAA6EtC,GAA7E,CAAiF1B,cAAcA,WAAWmG,0BAAX,EAA/F,CAAP;AACD;AAvBiB;;;;;;;;AAAdwK,wD;;;;;;;AA0BC,eAASnS,KAAT,CAAe2R,IAAf,EAAqB,GAAGpC,IAAxB,EAA8B;AACnC,eAAO,IAAImC,yBAAJ,CAA8BC,IAA9B,EAAoC,GAAGpC,IAAvC,CAAP;AACD;;;;AAED,YAAMwD,YAAY,OAAO3S,MAAP,KAAkB,WAAlB,GAAgCA,MAAhC,GAAyC;AAC3D,aAAOmH,IAAP,KAAgB,WAAhB,GAA8BA,IAA9B,GAAqC;AACrCyL,YAFA,C,CAEQ;;;;;;;;AAFFD,oD;;;;;;;AAIN,YAAM5L,iBAAN,CAAwB;AACtB;AACA,eAAO4K,gBAAP,CAAwB/R,KAAxB,EAA+B;AAC7BkC,+BAAqBiK,qBAArB,CAA2CnM,KAA3C;AACD;;AAED;AACA,eAAOoH,oBAAP,CAA4BF,MAA5B,EAAoCD,QAApC,EAA8CzF,UAA9C,EAA0DiD,IAA1D,EAAgE;AAC9DyC,iBAAOjF,OAAP,CAAejC,SAAS;AACtB,gBAAG,IAAIa,GAAJ,CAAQpC,cAAcwU,eAAd,EAAR,EAAyClR,GAAzC,CAA6C/B,KAA7C,CAAH,EAAwD;AACxDA,kBAAM6R,kBAAN;AACA7R,kBAAMkT,cAAN,CAAqBjM,QAArB,EAA+BzF,WAAWoB,MAAX,EAA/B,EAAoD6B,IAApD;AACD,WAJD;AAKD;;AAED;;;;;AAKA,eAAO0O,eAAP,CAAuBzE,GAAvB,EAA4B0E,IAA5B,EAAkC;AAChC,gBAAM5R,aAAagC,WAAWC,cAAX,CAA0BiL,GAA1B,EAA+B0E,IAA/B,EAAqC,QAArC,CAAnB;AACA9S,6BAAmBiB,mBAAnB,CAAuCC,UAAvC;AACD;;AAED,eAAO6R,eAAP,CAAuBC,UAAvB,EAAmC;AACjC,gBAAM9R,aAAagC,WAAWC,cAAX,CAA0BsP,SAA1B,EAAqCO,UAArC,EAAiD,QAAjD,CAAnB;AACAhT,6BAAmBiB,mBAAnB,CAAuCC,UAAvC;AACD;;AAED,eAAO+R,cAAP,CAAsBzL,KAAtB,EAA6B0L,OAA7B,EAAsC;AACpC,gBAAMhS,aAAagC,WAAWC,cAAX,CAA0BqE,KAA1B,EAAiC0L,OAAjC,EAA0C,OAA1C,CAAnB;AACAlT,6BAAmBiB,mBAAnB,CAAuCC,UAAvC;AACD;;AAjCqB;;;;;;;;AAAlB2F,4D;;;;;;;AAqCN,YAAMiH,cAAN,CAAqB;;AAEnB;;;;;AAKA,eAAOqF,aAAP,CAAqB/E,GAArB,EAA0B0E,IAA1B,EAAgCnM,QAAhC,EAA0C;AACxC,gBAAMzF,aAAaoC,mCAAmCyB,GAAnC,CAAuCqJ,GAAvC,EAA4C0E,IAA5C,CAAnB;AACA,cAAI,CAAC5R,UAAD,IAAe,CAACA,WAAWiE,cAA/B,EAA+C;AAC/CjE,qBAAWiE,cAAX,CAA0B0I,kBAA1B,CAA6ClH,QAA7C;AACD;;AAED,eAAOyM,aAAP,CAAqBJ,UAArB,EAAiCrM,QAAjC,EAA2C;AACzC,gBAAMzF,aAAaoC,mCAAmCyB,GAAnC,CAAuC0N,SAAvC,EAAkDO,UAAlD,CAAnB;AACA,cAAI,CAAC9R,UAAD,IAAe,CAACA,WAAWiE,cAA/B,EAA+C;AAC/CjE,qBAAWiE,cAAX,CAA0B0I,kBAA1B,CAA6ClH,QAA7C;AACD;;AAED,eAAO0M,YAAP,CAAoB7L,KAApB,EAA2B0L,OAA3B,EAAoCvM,QAApC,EAA8C;AAC5C,gBAAMzF,aAAaoC,mCAAmCyB,GAAnC,CAAuCyC,KAAvC,EAA8C0L,OAA9C,CAAnB;AACA,cAAI,CAAChS,UAAD,IAAe,CAACA,WAAWiE,cAA/B,EAA+C;AAC/CjE,qBAAWiE,cAAX,CAA0B0I,kBAA1B,CAA6ClH,QAA7C;AACD;;AAED,qBAAaoH,wBAAb,GAAwC;AACtC,cAAI/P,WAAWyI,SAAf,EAA0B,OAAOA,SAAP;AAC1B,gBAAM6M,QAAQtV,OAAOsV,KAAP,EAAd;AACA,gBAAMC,SAASD,MAAMC,MAArB;;AAEA,eAAK,IAAIC,KAAT,IAAkBD,OAAOE,KAAP,EAAlB,EAAkC;AAChC,gBAAI,CAACD,MAAM7O,IAAN,CAAWqG,QAAX,CAAoB,mBAApB,CAAL,EAA+C;AAC7C,qBAAO,MAAMwI,MAAME,sBAAN,EAAb;AACD;AACF;;AAED,gBAAMC,oBAAoBJ,OAAOtR,SAAP,CAAiBuR,SAASA,MAAMnC,IAAN,CAAWrG,QAAX,CAAoB,qBAApB,CAA1B,CAA1B;AACA,cAAG2I,qBAAqB,CAArB,IAA0BA,oBAAoBJ,OAAO7Q,MAAP,GAAgB,CAAjE,EAAoE;AAClE,mBAAO,MAAM6Q,OAAOI,oBAAoB,CAA3B,EAA8BD,sBAA9B,EAAb;AACD;AACD9S,kBAAQgT,GAAR,CAAYN,KAAZ;AACA,iBAAO7M,SAAP;AACD;;AA1CkB;;AA8CrB;;;;;;;;;;;;;AA9CMqH,yD;;;;;;;AAqDC,eAASrO,KAAT,GAAiB;AACtB6D,2CAAmCmJ,KAAnC;AACA7K,6BAAqB6K,KAArB;AACD;;AAED;AACA;;;;;;AAGO,eAASjN,WAAT,CAAqB4O,GAArB,EAA0B0E,IAA1B,EAAgC;AACrC,YAAIjT,sBAAJ,EAA4B;AAC1BgH,4BAAkBgM,eAAlB,CAAkCzE,GAAlC,EAAuC0E,IAAvC;AACD;AACF;;;;AAEM,eAASvT,SAAT,CAAmB6O,GAAnB,EAAwB0E,IAAxB,EAA8B;AACnC,YAAIjT,sBAAJ,EAA4B;AAC1BgH,4BAAkBgM,eAAlB,CAAkCzE,GAAlC,EAAuC0E,IAAvC;AACD;AACD,cAAMxK,SAAS8F,IAAI0E,IAAJ,CAAf;AACA,eAAOxK,MAAP;AACD;;;;AAEM,eAAShJ,gBAAT,CAA0B8O,GAA1B,EAA+B0E,IAA/B,EAAqC7D,OAAO,EAA5C,EAAgD;AACrD,YAAIpP,sBAAJ,EAA4B;AAC1BgH,4BAAkBgM,eAAlB,CAAkCzE,GAAlC,EAAuC0E,IAAvC;AACD;AACD,cAAMxK,SAAS8F,IAAI0E,IAAJ,EAAU,GAAG7D,IAAb,CAAf;AACA,eAAO3G,MAAP;AACD;;;;AAEM,eAASjJ,SAAT,CAAmB+O,GAAnB,EAAwB0E,IAAxB,EAA8Be,GAA9B,EAAmClN,QAAnC,EAA6C;AAClD,cAAM2B,SAAS8F,IAAI0E,IAAJ,IAAYe,GAA3B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASlJ,iBAAT,CAA2BgP,GAA3B,EAAgC0E,IAAhC,EAAsCe,GAAtC,EAA2ClN,QAA3C,EAAqD;AAC1D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASnJ,oBAAT,CAA8BiP,GAA9B,EAAmC0E,IAAnC,EAAyCe,GAAzC,EAA8ClN,QAA9C,EAAwD;AAC7D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASpJ,uBAAT,CAAiCkP,GAAjC,EAAsC0E,IAAtC,EAA4Ce,GAA5C,EAAiDlN,QAAjD,EAA2D;AAChE,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASrJ,iBAAT,CAA2BmP,GAA3B,EAAgC0E,IAAhC,EAAsCe,GAAtC,EAA2ClN,QAA3C,EAAqD;AAC1D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAStJ,kBAAT,CAA4BoP,GAA5B,EAAiC0E,IAAjC,EAAuCe,GAAvC,EAA4ClN,QAA5C,EAAsD;AAC3D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASvJ,uBAAT,CAAiCqP,GAAjC,EAAsC0E,IAAtC,EAA4Ce,GAA5C,EAAiDlN,QAAjD,EAA2D;AAChE,cAAM2B,SAAS8F,IAAI0E,IAAJ,MAAce,GAA7B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASxJ,kBAAT,CAA4BsP,GAA5B,EAAiC0E,IAAjC,EAAuCe,GAAvC,EAA4ClN,QAA5C,EAAsD;AAC3D,cAAM2B,SAAS8F,IAAI0E,IAAJ,MAAce,GAA7B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAASzJ,mBAAT,CAA6BuP,GAA7B,EAAkC0E,IAAlC,EAAwCe,GAAxC,EAA6ClN,QAA7C,EAAuD;AAC5D,cAAM2B,SAAS8F,IAAI0E,IAAJ,MAAce,GAA7B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAS1J,2BAAT,CAAqCwP,GAArC,EAA0C0E,IAA1C,EAAgDe,GAAhD,EAAqDlN,QAArD,EAA+D;AACpE,cAAM2B,SAAS8F,IAAI0E,IAAJ,OAAee,GAA9B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAS3J,mBAAT,CAA6ByP,GAA7B,EAAkC0E,IAAlC,EAAwCe,GAAxC,EAA6ClN,QAA7C,EAAuD;AAC5D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAS5J,mBAAT,CAA6B0P,GAA7B,EAAkC0E,IAAlC,EAAwCe,GAAxC,EAA6ClN,QAA7C,EAAuD;AAC5D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAS7J,kBAAT,CAA4B2P,GAA5B,EAAiC0E,IAAjC,EAAuCe,GAAvC,EAA4ClN,QAA5C,EAAsD;AAC3D,cAAM2B,SAAS8F,IAAI0E,IAAJ,KAAae,GAA5B;AACA/F,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAS9J,YAAT,CAAsB4P,GAAtB,EAA2B0E,IAA3B,EAAiCnM,QAAjC,EAA2C;AAChD,cAAM2B,SAAS,OAAO8F,IAAI0E,IAAJ,CAAtB;AACAhF,uBAAeqF,aAAf,CAA6B/E,GAA7B,EAAkC0E,IAAlC,EAAwCnM,QAAxC;AACA,eAAO2B,MAAP;AACD;;;;AAEM,eAAS/J,QAAT,CAAkBiJ,KAAlB,EAAyB0L,OAAzB,EAAkC1S,KAAlC,EAAyC;AAC9C,YAAIX,sBAAJ,EAA4B;AAC1B2H,gBAAM0L,OAAN,IAAiB1S,KAAjB;AACAqG,4BAAkBoM,cAAlB,CAAiCzL,KAAjC,EAAwC0L,OAAxC;AACD;AACF;;;;AAEM,eAAS5U,QAAT,CAAkBkJ,KAAlB,EAAyB0L,OAAzB,EAAkC1S,KAAlC,EAAyCmG,QAAzC,EAAmD;AACxDa,cAAM0L,OAAN,IAAiB1S,KAAjB;AACAsN,uBAAeuF,YAAf,CAA4B7L,KAA5B,EAAmC0L,OAAnC,EAA4CvM,QAA5C;AACD;;;;AAEM,eAAStI,SAAT,CAAmB2U,UAAnB,EAA+B;AACpC,YAAInT,sBAAJ,EAA4B;AAC1BgH,4BAAkBkM,eAAlB,CAAkCC,UAAlC;AACD;AACF;;;;AAEM,eAAS5U,SAAT,CAAmB4U,UAAnB,EAA+BrM,QAA/B,EAAyC;AAC9CmH,uBAAesF,aAAf,CAA6BJ,UAA7B,EAAyCrM,QAAzC;AACD;;;;yBAEcjH,K","file":"active-expression-rewriting.js","sourcesContent":["import 'lang';\n\n/*HTML \n<img src=\"https://lively-kernel.org/lively4/lively4-core/media/lively4_logo_smooth_100.png\"></img>'s Implementation of AExprs\nHTML*/\n\nimport { BaseActiveExpression } from 'active-expression';\nimport * as frameBasedAExpr from \"active-expression-frame-based\";\n\nimport Stack from './../utils/stack.js';\nimport CompositeKey from './composite-key.js';\nimport InjectiveMap from './injective-map.js';\nimport BidirectionalMultiMap from './bidirectional-multi-map.js';\nimport DualKeyMap from './dual-key-map.js';\nimport { isFunction } from 'utils';\nimport lively from \"src/client/lively.js\";\nimport _ from 'src/external/lodash/lodash.js';\nimport diff from 'src/external/diff-match-patch.js';\nimport { AExprRegistry } from 'src/client/reactive/active-expression/active-expression.js';\n\n/*MD # Dependency Analysis MD*/\n\nconst analysisStack = new Stack();\n\nlet expressionAnalysisMode = false;\nwindow.__expressionAnalysisMode__ = false;\n\nclass ExpressionAnalysis {\n\n  static recalculateDependencies(aexpr) {\n    if (analysisStack.findUp(({ currentAExpr }) => currentAExpr === aexpr)) {\n      throw new Error('Attempt to recalculate an Active Expression while it is already recalculating dependencies');\n    }\n\n    try {\n      expressionAnalysisMode = true;\n      window.__expressionAnalysisMode__ = expressionAnalysisMode;\n\n      // Do the function execution in ExpressionAnalysisMode\n      analysisStack.withElement({ currentAExpr: aexpr, dependencies: new Set() }, () => {\n        try {\n          const { value, isError } = aexpr.evaluateToCurrentValue();\n        } catch(e) {\n          console.error(\"Error during AE Dependency Calculation\", e.message);\n        }finally {\n          this.applyDependencies();\n        }\n      });\n    } finally {\n      expressionAnalysisMode = !!analysisStack.top();\n      window.__expressionAnalysisMode__ = expressionAnalysisMode;\n    }\n  }\n\n  static associateDependency(dependency) {\n    const { dependencies } = analysisStack.top();\n    dependencies.add(dependency);\n  }\n\n  static applyDependencies() {\n    const { currentAExpr, dependencies } = analysisStack.top();\n    \n    const currentDependencies = currentAExpr.dependencies().all();\n    const currentSet = new Set(currentDependencies);\n    let removedDependencies = currentDependencies\n      .filter(dependency => !dependencies.has(dependency));\n    const newDependencies = [...dependencies]\n      .filter(dependency => !currentSet.has(dependency));\n    \n    removedDependencies\n      .forEach(dependency => DependenciesToAExprs.disassociate(dependency, currentAExpr));\n    dependencies.forEach(dependency => {\n      DependenciesToAExprs.associate(dependency, currentAExpr);\n    });\n    \n    const matching = [];\n    removedDependencies = removedDependencies.filter((dependency) => {\n      const index = newDependencies.findIndex((dependency2 => this.equalish(dependency, dependency2)));\n      if(index >= 0) {\n        matching.push({removed: dependency.getKey(), added: newDependencies[index].getKey()});\n        dependency.currentVersion = newDependencies[index];\n        newDependencies.splice(index, 1);\n        return false;\n      }\n      return true;\n    });\n    if(newDependencies.length > 0 || removedDependencies.length > 0 || matching.length > 0) {\n      currentAExpr.logEvent('dependencies changed', { added: newDependencies.map(d => d.getKey()), removed: removedDependencies.map(d => d.getKey()), matching});\n    }\n  }\n\n  static equalish(d1, d2) {\n    if(d1.type() !== d2.type()) return false;\n    return _.isEqual(d1.getKey(), d2.getKey());\n  }\n  \n}\n\nclass Dependency {\n  static getOrCreateFor(context, identifier, type) {\n    return ContextAndIdentifierToDependencies.getOrCreate(context, identifier, () => new Dependency(context, identifier, type));\n  }\n  \n  // Generates a key for this dependency. This allows this dependency to be found again at a later time, after the originial dependency might have already been deleted.\n  getKey() {\n    return new DependencyKey(this.context, this.identifier);\n  }\n\n  // #TODO: compute and cache isGlobal\n  constructor(context, identifier, type) {\n    this._type = type;\n    this.classFilePath = context.__classFilePath__;\n    this.isTracked = false;\n    this.hooks = [];\n    this.context = context;\n    this.identifier = identifier;\n  }\n\n  updateTracking() {\n    if (this.isTracked === DependenciesToAExprs.hasAExprsForDep(this)) {\n      return;\n    }\n    if (this.isTracked) {\n      this.untrack();\n    } else {\n      this.track();\n    }\n    for (const hook of this.getHooks()) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    for (const ae of DependenciesToAExprs.getAExprsForDep(this)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\n    }\n  }\n\n  track() {\n    this.isTracked = true;\n\n    const [context, identifier, value] = this.contextIdentifierValue();\n    const isGlobal = this.isGlobalDependency();\n\n    /*HTML <span style=\"font-weight: bold;\">Source Code Hook</span>: for anything <span style=\"color: green; font-weight: bold;\">members or locals</span> HTML*/\n    // always employ the source code hook\n    this.sourceCodeHook = new SourceCodeHook(context, identifier);\n    this.associateWithHook(this.sourceCodeHook);\n\n    /*HTML <span style=\"font-weight: bold;\">Data Structure Hook</span>: for <span style=\"color: green; font-weight: bold;\">Sets, Arrays, Maps</span> HTML*/\n    let dataStructure;\n    if (this._type === 'member') {\n      dataStructure = context;\n    } else if (this._type === 'local') {\n      dataStructure = value;\n    }\n    if (dataStructure instanceof Array || dataStructure instanceof Set || dataStructure instanceof Map) {\n      this.associateWithHook(DataStructureHook.getOrCreateForDataStructure(dataStructure));\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Wrapping Hook</span>: only for <span style=\"color: green; font-weight: bold;\">\"that\"</span> HTML*/\n    if (isGlobal && identifier === 'that') {\n      const wrappingHook = PropertyWrappingHook.getOrCreateForProperty(identifier);\n      this.associateWithHook(wrappingHook);\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Mutation Observer Hook</span>: handling <span style=\"color: green; font-weight: bold;\">HTMLElements</span> HTML*/\n    if (this._type === 'member' && context instanceof HTMLElement) {\n      // #HACK #TODO: for now, ignore Knotview if unused for Mutations -> need to better separate those hooks, e.g. do not recursively check ALL attribute change, etc.\n      if (context.tagName !== 'LIVELY-TABLE' && !(context.tagName === 'KNOT-VIEW' && (identifier === 'knot' || identifier === 'knotLabel')) && !context.tagName.endsWith('-rp19')) {\n        // TODO: the member also influences what kind of observer we want to use!\n        this.associateWithHook(MutationObserverHook.getOrCreateForElement(context));\n      }\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Event-based Change Hook</span>: handling <span style=\"color: green; font-weight: bold;\">HTMLElements</span> HTML*/\n    if (this._type === 'member' && context instanceof HTMLElement) {\n      // #TODO: we have to acknowledge that different properties require different events to listen on\n      //  e.g. code-mirror might have 'value' (so need to listen for 'change') or 'getCursor' (so need to listen for 'cursorActivity')\n      // eventBasedHook.listenFor(identifier);\n      this.associateWithHook(EventBasedHook.getOrCreateForElement(context));\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Frame-based Change Hook</span>: handling <span style=\"color: green; font-weight: bold;\">Date</span> HTML*/\n    // -    if ((this._type === 'member' && context === Date && identifier === 'now') ||\n    if (isGlobal && identifier === 'Date') {\n      //TODO: This violates the each Hook belongs to one Dependency Rule\n      this.associateWithHook(FrameBasedHook.instance);\n    }\n  }\n\n  associateWithHook(hook) {\n    this.hooks.push(hook);\n    hook.addDependency(this);\n  }\n\n  untrack() {\n    this.isTracked = false;\n    ContextAndIdentifierToDependencies.removeSecondary(this.context, this.identifier);\n\n    // Track affected files\n    for (const hook of this.hooks) {\n      hook.removeDependency(this);\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    for (const ae of DependenciesToAExprs.getAExprsForDep(this)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\n    }\n  }\n\n  //Todo: Replace\n  contextIdentifierValue() {\n    const value = this.context !== undefined ? this.context[this.identifier] : undefined;\n\n    return [this.context, this.identifier, value];\n  }\n\n  notifyAExprs(location, hook) {\n    const aexprs = DependenciesToAExprs.getAExprsForDep(this);\n    DependencyManager.checkAndNotifyAExprs(aexprs, location, this, hook);\n  }\n\n  type() {\n    if (this.isGlobal()) return \"global\";\n    return this._type;\n  }\n\n  isMemberDependency() {\n    return this._type === 'member' && !this.isGlobal();\n  }\n  isGlobalDependency() {\n    return this._type === 'member' && this.isGlobal();\n  }\n  isLocalDependency() {\n    return this._type === 'local';\n  }\n  isGlobal() {\n    return this.context === self;\n  }\n\n  getHooks() {\n    return this.hooks;\n  }\n\n  getName() {\n    const [context, identifier] = this.contextIdentifierValue();\n\n    if (this.isGlobalDependency()) {\n      return identifier.toString();\n    }\n    return (context ? context.constructor.name : \"\") + \".\" + identifier;\n  }\n\n  getAsDependencyDescription() {\n    const [context, identifier, value] = this.contextIdentifierValue();\n\n    if (this.isMemberDependency()) {\n      return {\n        object: context,\n        property: identifier,\n        value\n      };\n    }\n\n    if (this.isGlobalDependency()) {\n      return {\n        name: identifier,\n        value\n      };\n    }\n\n    if (this.isLocalDependency()) {\n      return {\n        scope: context,\n        name: identifier,\n        value\n      };\n    }\n\n    throw new Error('Dependency is neighter local, member, nor global.');\n  }\n\n}\n/*MD # Debugging Cache MD*/\n\nexport class AEDebuggingCache {\n\n  constructor() {\n    this.registeredDebuggingViews = [];\n    this.debouncedUpdateDebuggingViews = _.debounce(this.updateDebggingViews, 100);\n    this.changedFiles = new Set();\n  }\n  /*MD ## Registration MD*/\n  async registerFileForAEDebugging(url, context, triplesCallback) {\n    const callback = async () => {\n      if (context && (!context.valid || context.valid())) {\n        triplesCallback((await this.getDependencyTriplesForFile(url)));\n        return true;\n      }\n      return false;\n    };\n    this.registeredDebuggingViews.push({ callback, url });\n\n    triplesCallback((await this.getDependencyTriplesForFile(url)));\n  }\n\n  getTripletsForAE(ae) {\n    const result = [];\n    for (const dependency of DependenciesToAExprs.getDepsForAExpr(ae)) {\n      for (const hook of dependency.getHooks()) {\n        result.push({ hook, dependency: dependency.getKey(), ae });\n      }\n    }\n    return result;\n  }\n\n  /*MD ## Caching MD*/\n\n  /*MD ## Code Change API MD*/\n  async updateFile(url, oldCode, newCode) {\n    try {\n      const lineMapping = this.calculateMapping(oldCode, newCode);\n      for (const ae of DependenciesToAExprs.getAEsInFile(url)) {\n        const location = ae.meta().get(\"location\");\n        this.remapLocation(lineMapping, location);\n      }\n      for (const hook of await this.getHooksInFile(url)) {\n        hook.getLocations().then(locations => {\n          for (const location of locations) {\n            this.remapLocation(lineMapping, location);\n          }\n        });\n      }\n    } catch (e) {\n      console.error(e);\n    }\n  }\n\n  remapLocation(lineMapping, location) {\n    let [diff, lineChanged] = lineMapping[location.start.line];\n\n    if (diff === -1) {\n      location.start.line = 0;\n    } else {\n      location.start.line = diff;\n    }\n\n    let [diff2, lineChanged2] = lineMapping[location.end.line];\n\n    if (diff2 === -1) {\n      location.end.line = 0;\n    } else {\n      location.end.line = diff2;\n    }\n    if (lineChanged || lineChanged2) {\n      lively.notify(\"Changed AE code for existing AE. There are outdated expressions in the system\");\n      //ToDo: Check if the content is similar enough, mark AEs as outdated\n    }\n  }\n\n  calculateMapping(oldCode, newCode) {\n    const mapping = []; //For each line of oldCode: new Line in newCode if existing, changedContent if the line no longer exists but can be mapped to a newCode line\n    var dmp = new diff.diff_match_patch();\n    var a = dmp.diff_linesToChars_(oldCode, newCode);\n    var lineText1 = a.chars1;\n    var lineText2 = a.chars2;\n    var lineArray = a.lineArray;\n    var diffs = dmp.diff_main(lineText1, lineText2, false);\n\n    let originalLine = 0;\n    let newLine = 0;\n    let recentDeletions = 0;\n    let recentAdditions = 0;\n    for (let [type, data] of diffs) {\n      if (type === 0) {\n        recentDeletions = 0;\n        recentAdditions = 0;\n        for (let i = 0; i < data.length; i++) {\n          mapping[originalLine] = [newLine, false];\n          originalLine++;\n          newLine++;\n        }\n      } else if (type === 1) {\n        if (recentDeletions > 0) {\n          const matchingLines = Math.max(recentDeletions, data.length);\n          for (let i = 0; i < matchingLines; i++) {\n            mapping[originalLine - matchingLines + i] = [newLine, true];\n            newLine++;\n          }\n          data = data.substring(matchingLines);\n        }\n        if (data.length > 0) {\n          newLine += data.length;\n          recentAdditions += data.length;\n        }\n      } else {\n        if (recentAdditions > 0) {\n          const matchingLines = Math.max(recentAdditions, data.length);\n          for (let i = 0; i < matchingLines; i++) {\n            mapping[originalLine] = [newLine - matchingLines + i, true];\n            originalLine++;\n          }\n          data = data.substring(matchingLines);\n        }\n        recentDeletions += data.length;\n        for (let i = 0; i < data.length; i++) {\n          mapping[originalLine] = [-1, false];\n          originalLine++;\n        }\n      }\n    }\n\n    dmp.diff_charsToLines_(diffs, lineArray);\n\n    return mapping;\n  }\n  /*MD ## Rewriting API MD*/\n  updateFiles(files) {\n    if (!files) return;\n    files.forEach(file => {\n      if(file) {\n        this.changedFiles.add(file)\n      }\n    });\n    this.debouncedUpdateDebuggingViews();\n  }\n\n  async updateDebggingViews() {\n    for (let i = 0; i < this.registeredDebuggingViews.length; i++) {\n      if (![...this.changedFiles].some(file => file.includes(this.registeredDebuggingViews[i].url))) continue;\n      if (!(await this.registeredDebuggingViews[i].callback())) {\n        this.registeredDebuggingViews.splice(i, 1);\n        i--;\n      }\n    }\n    this.changedFiles = new Set();\n  }\n\n  async getDependencyTriplesForFile(url) {\n    let result = [];\n    for (const ae of DependenciesToAExprs.getAEsInFile(url)) {\n      result = result.concat(this.getTripletsForAE(ae));\n    }\n    for (const hook of await this.getHooksInFile(url)) {\n      for(const dependency of hook.getDependencies()) {\n        for (const ae of DependenciesToAExprs.getAExprsForDep(dependency)) {\n          const location = ae.meta().get(\"location\").file;\n          // if the AE is also in this file, we already covered it with the previous loop\n          if (!location.includes(url)) {\n            result.push({ hook, dependency: dependency.getKey(), ae });\n          }\n        }\n      }\n    }\n    return result;\n  }\n\n  async getHooksInFile(url) {\n    const allHooks = ContextAndIdentifierToDependencies.allValues().flatMap(dep => dep.getHooks());\n    const hooksWithLocations = await Promise.all(allHooks.map(hook => {\n      return hook.getLocations().then(locations => {\n        return { hook, locations };\n      });\n    }));\n    return hooksWithLocations.filter(({ hook, locations }) => {\n      const location = locations.find(loc => loc && loc.file);\n      return location && location.file.includes(url);\n    }).map(({ hook, locations }) => hook);\n  }\n\n}\n\nasync function relatedFiles(dependencies, aexprs) {}\n\nexport const DebuggingCache = new AEDebuggingCache();\n\nconst DependenciesToAExprs = {\n  _depsToAExprs: new BidirectionalMultiMap(),\n  _AEsPerFile: new Map(),\n\n  associate(dep, aexpr) {\n    if(this._depsToAExprs.has(dep, aexpr)) return;\n    const location = aexpr.meta().get(\"location\");\n    if (location && location.file) {\n      DebuggingCache.updateFiles([location.file]);\n      this._AEsPerFile.getOrCreate(location.file, () => new Set()).add(aexpr);\n    } \n    this._depsToAExprs.associate(dep, aexpr);\n    dep.updateTracking();\n\n    // Track affected files\n    for (const hook of dep.getHooks()) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n  },\n  \n  disassociate(dep, aexpr) {\n    this._depsToAExprs.remove(dep, aexpr);\n    dep.updateTracking();\n    for (const hook of dep.getHooks()) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    //TODO: Remove AE from assiciated file, if it was the last dependency?\n  },\n\n  disconnectAllForAExpr(aexpr) {\n    const location = aexpr.meta().get(\"location\");\n    if (location && location.file) {\n      DebuggingCache.updateFiles([location.file]);\n      if (this._AEsPerFile.has(location.file)) {\n        this._AEsPerFile.get(location.file).delete(aexpr);\n      }\n    }\n    const deps = [...this.getDepsForAExpr(aexpr)];\n    this._depsToAExprs.removeAllLeftFor(aexpr);\n    deps.forEach(dep => {      \n      dep.updateTracking()\n    });\n\n    // Track affected files\n    for (const dep of deps) {\n      for (const hook of dep.getHooks()) {\n        hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n      }\n    }\n  },\n\n  getAEsInFile(url) {\n    for (const [location, aes] of this._AEsPerFile.entries()) {\n      if (location.includes(url)) return aes;\n    }\n    return [];\n  },\n\n  getAExprsForDep(dep) {\n    if (!this._depsToAExprs.hasLeft(dep)) return [];\n    return Array.from(this._depsToAExprs.getRightsFor(dep));\n  },\n  getDepsForAExpr(aexpr) {\n    if (!this._depsToAExprs.hasRight(aexpr)) return [];\n    return Array.from(this._depsToAExprs.getLeftsFor(aexpr));\n  },\n\n  hasAExprsForDep(dep) {\n    return this.getAExprsForDep(dep).length >= 1;\n  },\n  hasDepsForAExpr(aexpr) {\n    return this.getDepsForAExpr(aexpr).length >= 1;\n  },\n\n  /*\n   * Removes all associations.\n   */\n  clear() {\n    this._depsToAExprs.clear();\n    this._depsToAExprs.getAllLeft().forEach(dep => dep.updateTracking());\n  }\n};\n\nexport class DependencyKey {\n  constructor(context, identifier) {\n    this.context = context;\n    this.identifier = identifier;\n  }\n  \n  getDependency() {    \n    return ContextAndIdentifierToDependencies.get(this.context, this.identifier);\n  }\n  \n  equals(other) {\n    if(other.context === this.context) {\n      // Handle weird edgecase to deal with array[0] being the same as array[\"0\"]\n      if(Array.isArray(this.context)) {\n        if(typeof this.identifier !== typeof other.identifier) {\n          if(typeof this.identifier === \"string\") {\n            return this.identifier === (other.identifier + \"\");\n          }\n          if(typeof other.identifier === \"string\") {\n            return other.identifier === (this.identifier + \"\");\n          }\n        }\n      }\n      return other.identifier === this.identifier;\n    }\n    return false;\n  }\n  \n  getCurrentVersion() {\n    if(!this.currentVersion) {\n      return this;\n    } else {\n      this.currentVersion = this.currentVersion.getCurrentVersion();\n    }\n    return this.currentVersion;\n  }\n  \n  getValue() {\n    if(this.context instanceof Map) {\n      return this.context.get(this.identifier);      \n    } else if (this.context instanceof Set) {\n      return [...this.context][this.identifer];\n    } else {\n      return this.context[this.identifier];\n    }\n  }\n}\n\n// 1. Two step map with (obj|scope) as primary key and (prop|name) as secondary key mapping to the dependencies\nconst ContextAndIdentifierToDependencies = new DualKeyMap();\n\n//const ContextToIdentifier = new MultiMap();\n//const IdentifierToDependency = new InjectiveMap();\n// 1. (obj, prop) or (scope, name) -> ContextAndIdentifierCompositeKey\n// - given via ContextAndIdentifierCompositeKey\n\n// 2.1. ContextAndIdentifierCompositeKey 1<->1 Dependency\n// - CompositeKeyToDependencies\n//const CompositeKeyToDependencies = new InjectiveMap();\n// 2.2. Dependency *<->* AExpr\n// - DependenciesToAExprs\n\n/** Source Code Hooks */\n// 3.1. ContextAndIdentifierCompositeKey 1<->1 SourceCodeHook\n// - CompositeKeyToSourceCodeHook\n//const CompositeKeyToSourceCodeHook = new InjectiveMap();\n// 3.2. SourceCodeHook *<->* Dependency\n// - HooksToDependencies\n\n/** Data Structure Hooks */\n// 4.1 DataStructureHookByDataStructure\nconst DataStructureHookByDataStructure = new WeakMap(); // WeakMap<(Set/Array/Map), DataStructureHook>\n/** Wrapping Hooks */\n// 4.2 PropertyWrappingHookByProperty\nconst PropertyWrappingHookByProperty = new Map(); // Map<(String/Symbol), PropertyWrappingHook>\n/** Mutation Observer Hooks */\n// 4.3 DataStructureHookByDataStructure\nconst MutationObserverHookByHTMLElement = new WeakMap(); // WeakMap<HTMLElement, MutationObserverHook>\n/** XXX */\n// 4.4 XXX\nconst EventBasedHookByHTMLElement = new WeakMap(); // WeakMap<HTMLElement, EventBasedHook>\n\nclass Hook {\n  constructor() {\n    this.dependencies = new Set();\n    this.installed = false;\n    this.locations = [];\n  }\n\n  addLocation(location) {\n    if (!location) return;\n    if (!this.locations.some(loc => _.isEqual(loc, location))) {\n      this.locations.push(location);\n    }\n    //Todo: Promises get added multiple times... Also, use a Set?\n  }\n  \n  getDependencies() {\n    return this.dependencies;\n  }\n\n  addDependency(dependency) {\n    this.dependencies.add(dependency);\n  }\n\n  removeDependency(dependency) {\n    this.dependencies.delete(dependency);\n  }\n\n  async getLocations() {\n    this.locations = await Promise.all(this.locations);\n    this.locations = this.locations.filter(l => l);\n    this.locations = _.uniqWith(this.locations, _.isEqual);\n    return this.locations;\n  }\n\n  informationString() {\n    return \"Generic Hook\";\n  }\n\n  notifyDependencies(location) {\n    const loc = location || TracingHandler.findRegistrationLocation();\n    this.addLocation(loc);\n\n    this.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    for(const dep of [...this.dependencies]) {\n      for (const ae of DependenciesToAExprs.getAExprsForDep(dep)) {\n        if (ae.meta().has(\"location\")) {\n          DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n        }\n      }      \n      dep.notifyAExprs(loc, this);\n    }\n  }\n}\n\nclass SourceCodeHook extends Hook {\n\n  informationString() {\n    return \"SourceCodeHook: \" + this.context + \".\" + this.identifier;\n  }\n\n  constructor(context, identifier) {\n    super();\n\n    this.context = context;\n    this.identifier = identifier;\n  }\n\n  install() {}\n  uninstall() {}\n}\n\nclass DataStructureHook extends Hook {\n  static getOrCreateForDataStructure(dataStructure) {\n    return DataStructureHookByDataStructure.getOrCreate(dataStructure, () => new DataStructureHook(dataStructure));\n  }\n  constructor(dataStructure) {\n    super();\n    this.monitorProperties(dataStructure);\n\n    // set.add = function add(...args) {\n    //   const result = Set.prototype.add.call(this, ...args);\n    //   hook.notifyDependencies();\n    //   return result;\n    // }\n  }\n\n  getPrototypeDescriptors(obj) {\n    const proto = obj.constructor.prototype;\n\n    const descriptors = Object.getOwnPropertyDescriptors(proto);\n    return Object.entries(descriptors).map(([key, desc]) => (desc.key = key, desc));\n  }\n\n  wrapProperty(obj, descriptor, after) {\n    Object.defineProperty(obj, descriptor.key, Object.assign({}, descriptor, {\n      value(...args) {\n        try {\n          return descriptor.value.apply(this, args);\n        } finally {\n          after.call(this, ...args);\n        }\n      }\n    }));\n  }\n\n  monitorProperties(obj) {\n    const myself = this;\n    const prototypeDescriptors = this.getPrototypeDescriptors(obj);\n    Object.entries(Object.getOwnPropertyDescriptors(obj)); // unused -> need for array\n\n    // the property constructor needs to be a constructor if called (as in cloneDeep in lodash);\n    // We can also leave out functions that do not change the state\n    const ignoredDescriptorKeys = new Set([\"at\", \"get\", \"constructor\", \"concat\", \"entries\", \"every\", \"filter\", \"find\", \"findIndex\", \"forEach\", \"includes\", \"indexOf\", \"join\", \"keys\", \"lastIndexOf\", \"reduce\", \"reduceRight\", \"slice\", \"toString\", \"toLocaleString\", \"values\"]);\n    \n    prototypeDescriptors\n      .filter(descriptor => !ignoredDescriptorKeys.has(descriptor.key))\n      .forEach(addDescriptor => {\n      // var addDescriptor = prototypeDescriptors.find(d => d.key === 'add')\n      if (addDescriptor.value) {\n        if (isFunction(addDescriptor.value)) {\n          this.wrapProperty(obj, addDescriptor, function () {\n            // #HACK #TODO we need an `withoutLayer` equivalent here\n            if (window.__compareAExprResults__) {\n              return;\n            }\n\n            this; // references the modified container\n            myself.notifyDependencies();\n          });\n        } else {\n          // console.warn(`Property ${addDescriptor.key} has a value that is not a function, but ${addDescriptor.value}.`)\n        }\n      } else {\n          // console.warn(`Property ${addDescriptor.key} has no value.`)\n        }\n    });\n  }\n\n  informationString() {\n    return \"DataStructureHook\";\n  }\n}\n\nclass PropertyWrappingHook extends Hook {\n  static getOrCreateForProperty(property) {\n    return PropertyWrappingHookByProperty.getOrCreate(property, () => new PropertyWrappingHook(property));\n  }\n\n  constructor(property) {\n    super();\n    this.property = property;\n    this.value = self[property];\n    const { configurable, enumerable } = Object.getOwnPropertyDescriptor(self, property);\n\n    // #TODO: keep old property accessors if present (otherwise, we do not interact with COP and ourselves, i.e. other property wrappers)\n    Object.defineProperty(self, property, {\n      configurable,\n      enumerable,\n\n      get: () => this.value,\n      set: value => {\n        const result = this.value = value;\n        this.notifyDependencies();\n        return result;\n      }\n    });\n  }\n\n  informationString() {\n    return \"PropertyWrappingHook: \" + this.property;\n  }\n}\n\nclass MutationObserverHook extends Hook {\n  static getOrCreateForElement(element) {\n    return MutationObserverHookByHTMLElement.getOrCreate(element, () => new MutationObserverHook(element));\n  }\n  constructor(element) {\n    super();\n\n    this._element = element;\n\n    const o = new MutationObserver((mutations, observer) => {\n      // const mutationRecords = o.takeRecords();\n      // lively.notify(`mutation on ${this._element.tagName}; ${mutations\n      //               .filter(m => m.type === \"attributes\")\n      //               .map(m => m.attributeName).join(', ')}.`)\n      this.changeHappened();\n      // mutations.forEach(mutation => {\n      //   if(mutation.type == \"attributes\") {\n      //     lively.notify(\n      //       `${mutation.oldValue} -> ${mutation.target.getAttribute(mutation.attributeName)}`,\n      //       `attribute: ${mutation.attributeName}`\n      //     );\n      //   }\n      //   if(mutation.type == \"characterData\") {\n      //     lively.notify(\n      //       `${mutation.oldValue}}`,\n      //       `characterData`\n      //     );\n      //   }\n      //   if(mutation.type == \"childList\") {\n      //     lively.success(\n      //       `${mutation.addedNodes.length} added, ${mutation.removedNodes.length} removed`,\n      //       `childList`\n      //     );\n      //   }\n      // });\n    });\n\n    o.observe(this._element, {\n      attributes: true,\n      attributeFilter: undefined,\n      attributeOldValue: true,\n\n      characterData: true,\n      characterDataOldValue: true,\n\n      childList: true,\n\n      subtree: true\n    });\n\n    // o.disconnect();\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n\n  informationString() {\n    return \"MutationObserverHook: \" + this._element;\n  }\n}\n\nclass EventBasedHook extends Hook {\n  static getOrCreateForElement(element) {\n    return EventBasedHookByHTMLElement.getOrCreate(element, () => new EventBasedHook(element));\n  }\n  \n  constructor(element) {\n    super();\n\n    this._element = element;\n\n    // #TODO: when the type of an input element changes, 'value' or 'checked' become unavailable\n    if (this._element.tagName === 'INPUT' || this._element.tagName === 'TEXTAREA') {\n      this._element.addEventListener('input', () => {\n        this.changeHappened();\n      });\n    } else if (this._element.tagName === 'LIVELY-CODE-MIRROR') {\n      this._element.editor.on('changes', () => {\n        this.changeHappened();\n      });\n    }\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n\n  informationString() {\n    return \"EventBasedHook: \" + this._element;\n  }\n}\n\nclass FrameBasedHook extends Hook {\n  static get instance() {\n    if (!this._instance) {\n      this._instance = new FrameBasedHook();\n      //Initialization is split to avoid endless recursion\n      this._instance.initializeAe();\n    }\n    return this._instance;\n  }\n\n  initializeAe() {\n    let x = 0;\n    // #TODO: caution, we currently use a side-effect function! How can we mitigate this? E.g. using `Date.now()` as expression\n    let ae = frameBasedAExpr.aexpr(() => x++);\n    ae.isMeta(true);\n    ae.onChange(() => {\n      this.changeHappened();\n    });\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n\n  informationString() {\n    return \"FrameBasedHook\";\n  }\n}\n\nexport class RewritingActiveExpression extends BaseActiveExpression {\n  constructor(func, ...args) {\n    super(func, ...args);\n    this.meta({ strategy: 'Rewriting' });\n    this.updateDependencies();\n  }\n\n  dispose() {\n    super.dispose();\n    DependencyManager.disconnectAllFor(this);\n  }\n\n  // #TODO: why is this defined here, and not in the superclass?\n  asAExpr() {\n    return this;\n  }\n\n  updateDependencies() {\n    if (this.isDisabled()) {\n      return;\n    }\n\n    ExpressionAnalysis.recalculateDependencies(this);\n  }\n  supportsDependencies() {\n    return true;\n  }\n\n  dependencies() {\n    return new DependencyAPI(this);\n  }\n\n  sharedDependenciesWith(otherAExpr) {\n    const ownDependencies = this.dependencies().all();\n    const otherDependencies = otherAExpr.dependencies().all();\n    const [own, shared, other] = ownDependencies.computeDiff(otherDependencies);\n    return shared;\n  }\n}\n\nclass DependencyAPI {\n  constructor(aexpr) {\n    this._aexpr = aexpr;\n  }\n\n  getDependencies() {\n    return DependenciesToAExprs.getDepsForAExpr(this._aexpr);\n  }\n\n  all() {\n    return Array.from(this.getDependencies());\n  }\n\n  locals() {\n    return this.getDependencies().filter(dependency => dependency.isLocalDependency()).map(dependency => dependency.getAsDependencyDescription());\n  }\n\n  members() {\n    return this.getDependencies().filter(dependency => dependency.isMemberDependency()).map(dependency => dependency.getAsDependencyDescription());\n  }\n\n  globals() {\n    return this.getDependencies().filter(dependency => dependency.isGlobalDependency()).map(dependency => dependency.getAsDependencyDescription());\n  }\n}\n\nexport function aexpr(func, ...args) {\n  return new RewritingActiveExpression(func, ...args);\n}\n\nconst globalRef = typeof window !== \"undefined\" ? window : // browser tab\ntypeof self !== \"undefined\" ? self : // web worker\nglobal; // node.js\n\nclass DependencyManager {\n  // #TODO, #REFACTOR: extract into own method; remove from this class\n  static disconnectAllFor(aexpr) {\n    DependenciesToAExprs.disconnectAllForAExpr(aexpr);\n  }\n\n  // #TODO, #REFACTOR: extract into configurable dispatcher class\n  static checkAndNotifyAExprs(aexprs, location, dependency, hook) {\n    aexprs.forEach(aexpr => {\n      if(new Set(AExprRegistry.evaluationStack()).has(aexpr)) return;\n      aexpr.updateDependencies();\n      aexpr.checkAndNotify(location, dependency.getKey(), hook);\n    });\n  }\n\n  /**\n   * **************************************************************\n   * ********************** associate *****************************\n   * **************************************************************\n   */\n  static associateMember(obj, prop) {\n    const dependency = Dependency.getOrCreateFor(obj, prop, 'member');\n    ExpressionAnalysis.associateDependency(dependency);\n  }\n\n  static associateGlobal(globalName) {\n    const dependency = Dependency.getOrCreateFor(globalRef, globalName, 'member');\n    ExpressionAnalysis.associateDependency(dependency);\n  }\n\n  static associateLocal(scope, varName) {\n    const dependency = Dependency.getOrCreateFor(scope, varName, 'local');\n    ExpressionAnalysis.associateDependency(dependency);\n  }\n\n}\n\nclass TracingHandler {\n\n  /**\n   * **************************************************************\n   * ********************** update ********************************\n   * **************************************************************\n   */\n  static memberUpdated(obj, prop, location) {\n    const dependency = ContextAndIdentifierToDependencies.get(obj, prop);\n    if (!dependency || !dependency.sourceCodeHook) return;\n    dependency.sourceCodeHook.notifyDependencies(location);\n  }\n\n  static globalUpdated(globalName, location) {\n    const dependency = ContextAndIdentifierToDependencies.get(globalRef, globalName);\n    if (!dependency || !dependency.sourceCodeHook) return;\n    dependency.sourceCodeHook.notifyDependencies(location);\n  }\n\n  static localUpdated(scope, varName, location) {\n    const dependency = ContextAndIdentifierToDependencies.get(scope, varName);\n    if (!dependency || !dependency.sourceCodeHook) return;\n    dependency.sourceCodeHook.notifyDependencies(location);\n  }\n\n  static async findRegistrationLocation() {\n    if (lively === undefined) return undefined;\n    const stack = lively.stack();\n    const frames = stack.frames;\n\n    for (let frame of frames.slice()) {\n      if (!frame.file.includes(\"active-expression\")) {\n        return await frame.getSourceLocBabelStyle();\n      }\n    }\n\n    const notificationFrame = frames.findIndex(frame => frame.func.includes(\".notifyDependencies\"));\n    if(notificationFrame >= 0 && notificationFrame < frames.length - 1) {      \n      return await frames[notificationFrame + 1].getSourceLocBabelStyle();\n    }\n    console.log(stack);\n    return undefined;\n  }\n\n}\n\n/*\n * Disconnects all associations between active expressions and object properties\n * As a result no currently enable active expression will be notified again,\n * effectively removing them from the system.\n *\n * #TODO: Caution, this might break with some semantics, if we still have references to an aexpr!\n */\nexport function reset() {\n  ContextAndIdentifierToDependencies.clear();\n  DependenciesToAExprs.clear();\n}\n\n/*MD # Source Code Point Cuts MD*/\n/**\n * (C)RUD for member attributes\n */\nexport function traceMember(obj, prop) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n}\n\nexport function getMember(obj, prop) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n  const result = obj[prop];\n  return result;\n}\n\nexport function getAndCallMember(obj, prop, args = []) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n  const result = obj[prop](...args);\n  return result;\n}\n\nexport function setMember(obj, prop, val, location) {\n  const result = obj[prop] = val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberAddition(obj, prop, val, location) {\n  const result = obj[prop] += val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberSubtraction(obj, prop, val, location) {\n  const result = obj[prop] -= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberMultiplication(obj, prop, val, location) {\n  const result = obj[prop] *= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberDivision(obj, prop, val, location) {\n  const result = obj[prop] /= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberRemainder(obj, prop, val, location) {\n  const result = obj[prop] %= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberExponentiation(obj, prop, val, location) {\n  const result = obj[prop] **= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberLeftShift(obj, prop, val, location) {\n  const result = obj[prop] <<= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberRightShift(obj, prop, val, location) {\n  const result = obj[prop] >>= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberUnsignedRightShift(obj, prop, val, location) {\n  const result = obj[prop] >>>= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberBitwiseAND(obj, prop, val, location) {\n  const result = obj[prop] &= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberBitwiseXOR(obj, prop, val, location) {\n  const result = obj[prop] ^= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberBitwiseOR(obj, prop, val, location) {\n  const result = obj[prop] |= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function deleteMember(obj, prop, location) {\n  const result = delete obj[prop];\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function getLocal(scope, varName, value) {\n  if (expressionAnalysisMode) {\n    scope[varName] = value;\n    DependencyManager.associateLocal(scope, varName);\n  }\n}\n\nexport function setLocal(scope, varName, value, location) {\n  scope[varName] = value;\n  TracingHandler.localUpdated(scope, varName, location);\n}\n\nexport function getGlobal(globalName) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateGlobal(globalName);\n  }\n}\n\nexport function setGlobal(globalName, location) {\n  TracingHandler.globalUpdated(globalName, location);\n}\n\nexport default aexpr;"]}