{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-tom/src/components/widgets/ast-capabilities.js"],"names":["loc","range","FileIndex","diff","babelDefault","lineLength","copyCursor","DMP_DELETION","DMP_EQUALITY","DMP_INSERTION","babel","t","types","template","Pos","CodeMirror","cur","line","ch","cm","lineNum","getLine","length","ASTCapabilities","constructor","codeProvider","codeChanged","selectionRanges","selections","firstSelection","map","_getFirstSelectionOrCursorPosition","anchor","cursor","head","newlineAndIndent","after","codeMirror","insertAt","getCursor","firstLine","replaceRange","setCursor","newlineFn","commands","newlineAndIndentContinueComment","livelyNotify","livelyCodeMirror","lcm","before","selectionTexts","getSelections","replaceSelections","listSelections","forEach","left","right","isBefore","setSelections","undefined","scroll","lively4url","l4url","l4urlplus","simples","Set","i","add","has","replaceParentWithSelection","scrollInfo","lively","noti","exitedEarly","pathLocationToSelect","transformed","sourceCode","transformAsAST","visitor","Program","programPath","selectedPath","getInnermostPathContainingSelection","parentPath","warn","getPathLocation","replaceWith","node","code","pathsToSelect","pathLocationsToPathes","selectPaths","scrollTo","generateIf","type","pathLocationsToSelect","statement","getStatementParent","push","ifStatement","booleanLiteral","identifier","getFirstSelectedIdentifier","name","scope","hasBinding","binding","getBinding","includes","kind","constantViolations","cv","getFirstSelectedIdentifierWithName","declarationIdentifierPath","getBindingDeclarationIdentifierPath","isVariableDeclarator","referencePaths","identifierPaths","variableDeclarator","findParent","variableDeclaration","isVariableDeclaration","initPath","get","remove","p","o","a","b","swapConditional","find","isIfStatement","then","consequent","alternate","blockStatement","body","negateExpression","negatableBinaryOperators","pathToNegate","parentKey","isBinaryExpression","operator","isUnaryExpression","negatedOperator","unaryExpression","insertMarkdownComment","around","fill","braveNewWorld","highlightChanges","from","document","querySelector","editor","to","targetLCM","targetCM","oldText","getValue","newText","value","dmp","diff_match_patch","d","diff_main","index","firstChangeStep","onlySpaces","str","trim","changeType","text","highlightChange","posFromIndex","slurpOrBarf","slurp","barf","forward","getScrollInfo","setScrollInfo","scrollIntoView","top","width","bottom","height","res","path","first","innerBlock","isBlock","outerStatement","getNextSibling","getPrevSibling","pathToSlurp","pushContainer","unshiftContainer","pathToBarf","last","insertAfter","insertBefore","myProgramPath","parsingFailed","programPathFor","traverseAsAST","err","rootNode","parent","finishedEnrichment","memberAssignments","Map","aexprs","canParse","nextPath","startingPath","isValid","pathToShow","traverse","enter","stop","getLastPath","nextPathCallback","getFirstChildOrSelf","child","getPathBeforeCursor","selectionStart","foundPath","exit","pathLocation","pathEnd","end","selection","nextPathContainingCursor","newStartingPath","containsRange","prevPath","getSelectedPaths","pathContainingWholeSelection","isPathExactlySelected","selectedPaths","containsPartsOfRange","skip","flat","getSelectedStatements","getOutermostPathContainingSelectionWithMinimalSelectionRange","isStatement","isBlockStatement","Statement","getSelectedExpressions","isExpression","isIdentifier","Expression","currentPath","isEqual","forwardList","linearizedPathList","backwardList","reverse","selectNextASTNodeWith","condition","reversed","pathList","maxPaths","getNextASTNodeInListWith","startPath","Identifier","getAllIdentifiers","identifiers","getDeclaration","getBindingsInFile","astBindings","getASTBinding","getClassBindings","isMemberExpression","isThisExpression","object","classPath","getClassPath","methodPath","getMethodPath","getClassMethodBindings","getMemberBindings","isClassMethod","classMethod","methodIdentifier","getUnbound","members","getAllUnboundIdentifierNames","unboundIdentifiers","filter","self","indexOf","conditionFunc","currentPathInList","pathInList","currentIndex","selectNodes","nodes","selectStringContentsOnly","ranges","selectedRange","start","_cmCharacter","paths","ClassMethod","key","FunctionDeclaration","id","ClassDeclaration","getColorLiterals","pPath","colorPaths","colorRegex","StringLiteral","match","expandSelection","strictlyContainsRange","reduceSelection","selectNextASTChild","currentNode","nextNode","isLiteral","isSuper","isDebuggerStatement","selectNextASTNodeLikeThis","selectNextReference","bindings","sortedBindings","sort","selectDeclaration","identName","declaration","isImportSpecifier","classUrls","getCorrespondingClasses","arr","cl","url","functionUrls","getFunctionExportURLs","urls","concat","openBrowser","container","asyncGet","livelyEditor","newCodeMirror","awaitEditor","astCapabilities","ac","rename","bindingItems","getPossibleBindingsAcrossFiles","comp","openComponentInWindow","focus","setAdditionalInput","setTitle","references","selectItems","newName","getAdditionalInput","camelCase","reference","fetch","r","codeLines","split","String","prototype","replaceBetween","what","substring","newCode","join","files","saveFile","reloadModule","System","import","selectBindings","printAllBindings","openReferencesMenu","current","ids","db","file","some","toArray","program","column","lastIndexOf","identifierName","findImports","functions","classes","isInDescribe","possiblePath","isIn","callee","isDirectlyIn","Array","elem","reduce","accu","updateColor","currentLocation","color","location","isStringLiteral","openHTMLAccessorsMenu","initialSelectionState","getExistingAccessors","classMethodIdentifier","ExportDefaultDeclaration","generateHTMLAccessors","compileListOfIDs","existingMethods","generateMethodNameFromProperty","selectedItems","item","generateCodeFragment","compileHTMLGetter","htmlURI","html","fetchText","tmp","innerHTML","childNodes","content","querySelectorAll","ea","htmlLines","idsWithLocation","indexOfId","generateTestCase","compileTestCase","generateGetter","compileGetter","generateSetter","compileSetter","generateClass","compileClass","replacementGenerator","identifierObject","generatedCode","pathBefore","pathWithin","pathToSelect","explanation","EXP","stringLiteral","propertyName","returnStatement","memberExpression","thisExpression","expressionStatement","assignmentExpression","className","classDeclaration","classBody","property","methodName","callExpression","addImport","importName","isFunction","existingImportStatement","isImportDeclaration","source","importStatement","importDeclaration","importSpecifier","unshift","specifiers","spec","imported","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","newMethod","async","static","methodCall","awaitExpression","variableType","objectPattern","replaceWithMultiple","extractMethod","extraction","selectMethodExtraction","parameters","silent","expressions","extractExpressionIntoLocalVariable","done","pathLocationToBeExtracted","isSelectedPath","ensureBlock","statements","blockNode","isArrowFunctionExpression","Error","targetLocation","blockLocation","isFor","isWhile","becameABlock","replace","resultExtracted","pathByLocationFromProgram","generateUidIdentifier","decl","ID","INIT","referree","insertedDeclaration","insertedDeclarationIdentifier","inlineLocalVariable","foo","wrapExpressionIntoActiveExpression","ae","EXPR","expression","pathRange","reg","result","exec","part","startsWith","parseInt","pathLocations","possibleClasses","methods","me","possibleExports","exports","where","anyOf","locations","e","eCl","exp"],"mappings":"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","file":"ast-capabilities.js","sourcesContent":["import { loc, range } from 'utils';\n\nimport FileIndex from \"src/client/fileindex.js\";\n\nimport diff from 'src/external/diff-match-patch.js';\nconst DMP_DELETION = -1,\n      DMP_EQUALITY = 0,\n      DMP_INSERTION = 1;\n\nimport babelDefault from 'systemjs-babel-build';\nconst babel = babelDefault.babel;\n\nconst t = babel.types;\nconst template = babel.template;\n\nvar Pos = CodeMirror.Pos;\nfunction copyCursor(cur) {\n  return Pos(cur.line, cur.ch);\n}\nfunction lineLength(cm, lineNum) {\n  return cm.getLine(lineNum).length;\n}\n\nexport default class ASTCapabilities {\n\n  constructor(codeProvider) {\n    this.codeProvider = codeProvider;\n    this.codeChanged();\n  }\n\n  get selectionRanges() {\n    if (this.codeProvider.selections.length == 0) {\n      return this.firstSelection;\n    }\n    return this.codeProvider.selections.map(range);\n  }\n\n  get firstSelection() {\n    return range(this._getFirstSelectionOrCursorPosition());\n  }\n\n  _getFirstSelectionOrCursorPosition() {\n    if (this.codeProvider.selections.length == 0) {\n      return { anchor: this.codeProvider.cursor, head: this.codeProvider.cursor };\n    }\n    return this.codeProvider.selections[0];\n  }\n\n  newlineAndIndent(after) {\n    const cm = this.codeProvider.codeMirror;\n\n    const insertAt = copyCursor(cm.getCursor());\n    if (insertAt.line === cm.firstLine() && !after) {\n      // Special case for inserting newline before start of document.\n      cm.replaceRange('\\n', Pos(cm.firstLine(), 0));\n      cm.setCursor(cm.firstLine(), 0);\n    } else {\n      insertAt.line = after ? insertAt.line : insertAt.line - 1;\n      insertAt.ch = lineLength(cm, insertAt.line);\n      cm.setCursor(insertAt);\n      var newlineFn = CodeMirror.commands.newlineAndIndentContinueComment || CodeMirror.commands.newlineAndIndent;\n      newlineFn(cm);\n    }\n  }\n\n  livelyNotify() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    const before = 'lively.notify(';\n    const after = ')';\n\n    const selectionTexts = cm.getSelections();\n    cm.replaceSelections(selectionTexts.map(t => before + t + after), \"around\"\n    // selections.forEach()\n    );const selections = cm.listSelections();\n    selections.forEach(({ anchor, head }) => {\n      const [left, right] = loc(anchor).isBefore(head) ? [anchor, head] : [head, anchor];\n      left.ch += before.length;\n      right.ch -= after.length;\n    });\n    cm.setSelections(selections, undefined, {\n      scroll: false\n    });\n  }\n\n  lively4url() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    const l4url = 'lively4url';\n    const l4urlplus = l4url + ' + ';\n\n    const selectionTexts = cm.getSelections();\n    const simples = new Set();\n    cm.replaceSelections(selectionTexts.map((t, i) => {\n      if (t.length > 0) {\n        return l4urlplus + t;\n      } else {\n        simples.add(i);\n        return l4url;\n      };\n    }), \"around\");\n    const selections = cm.listSelections();\n    selections.forEach(({ anchor, head }, i) => {\n      const [left, right] = loc(anchor).isBefore(head) ? [anchor, head] : [head, anchor];\n      if (simples.has(i)) {\n        left.ch += l4url.length;\n      } else {\n        // select `lively4url + <prior>`\n      }\n    });\n    cm.setSelections(selections, undefined, {\n      scroll: false\n    });\n  }\n  // replace parent with me\n  // #TODO: also for multiselections\n  replaceParentWithSelection() {\n    const scrollInfo = this.scrollInfo;\n    lively.noti;\n    let exitedEarly = false;\n\n    let pathLocationToSelect;\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const parentPath = selectedPath.parentPath;\n\n          // #TODO: which cases do we not want to support?\n          if (false) {\n            lively.warn('special case not supported');\n            exitedEarly = true;\n            return;\n          }\n\n          //           // #TODO: smooth some rough edges\n\n          //           const variableDeclarator = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclarator());\n          //           const variableDeclaration = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclaration());\n          //           const initPath = variableDeclarator.get('init');\n\n          // default case\n          pathLocationToSelect = parentPath.getPathLocation();\n          parentPath.replaceWith(selectedPath.node);\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes([pathLocationToSelect]);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  generateIf(type) {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const statement = selectedPath.getStatementParent();\n          pathLocationsToSelect.push(statement.getPathLocation() + '.test');\n\n          statement.replaceWith(t.ifStatement(t.booleanLiteral(true), statement.node));\n          if (type === 'condition') {} else if (type === 'then') {} else if (type === 'else') {}\n\n          return;\n\n          const identifier = this.getFirstSelectedIdentifier(selectedPath);\n          if (!identifier) {\n            lively.warn('no identifier selected');\n            exitedEarly = true;\n            return;\n          }\n\n          const name = identifier.node.name;\n          if (!identifier.scope.hasBinding(name)) {\n            lively.warn('no binding found for ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          let binding = identifier.scope.getBinding(name);\n          if (!binding) {\n            lively.warn('selected identifier is not referencing a variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          if (!['var', 'let', 'const'].includes(binding.kind)) {\n            lively.warn('binding for \"' + name + '\" is of kind \"' + binding.kind + '\" but should be any of \"var\", \"let\", or \"const\"');\n            exitedEarly = true;\n            return;\n          }\n\n          const constantViolations = binding.constantViolations.map(cv => this.getFirstSelectedIdentifierWithName(cv, binding.identifier.name));\n          if (constantViolations.length > 0) {\n            lively.warn('cannot inline because there is a constant violation for variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          const declarationIdentifierPath = this.getBindingDeclarationIdentifierPath(binding);\n          if (!declarationIdentifierPath.parentPath.isVariableDeclarator()) {\n            lively.warn('declaration is probably in a destructuring');\n            exitedEarly = true;\n            return;\n          }\n\n          const referencePaths = binding.referencePaths;\n          if (referencePaths.length === 0) {\n            lively.warn('variable \"' + name + '\" is never referenced');\n            exitedEarly = true;\n            return;\n          }\n\n          const identifierPaths = [declarationIdentifierPath, ...referencePaths, ...constantViolations];\n          if (!identifierPaths.includes(identifier)) {\n            lively.warn('selected identifier is not referencing a variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          const variableDeclarator = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclarator());\n          const variableDeclaration = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclaration());\n          const initPath = variableDeclarator.get('init');\n\n          // remove declaration\n          if (variableDeclaration.get('declarations').length === 1) {\n            variableDeclaration.remove();\n          } else {\n            variableDeclarator.remove();\n          }\n\n          // inline declaration\n          referencePaths.forEach(p => {\n            pathLocationsToSelect.push(p.getPathLocation());\n          });\n          referencePaths.forEach(p => {\n            p.replaceWith(initPath.node);\n          });\n          const o = { a: 42, b: 17 };\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  // # Swap if and else blocks of a conditional\n  swapConditional() {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const ifStatement = selectedPath.find(p => p.isIfStatement());\n          if (!ifStatement) {\n            lively.warn('not within an if statement');\n            exitedEarly = true;\n            return;\n          }\n\n          pathLocationsToSelect.push(ifStatement.getPathLocation());\n\n          const then = ifStatement.node.consequent;\n          ifStatement.node.consequent = ifStatement.node.alternate || t.blockStatement([]);\n          if (then.type === 'BlockStatement' && then.body.length === 0) {\n            ifStatement.node.alternate = null;\n          } else {\n            ifStatement.node.alternate = then;\n          }\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  // # Swap if and else blocks of a conditional\n  negateExpression() {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const negatableBinaryOperators = {\n            \"==\": \"!=\",\n            \"!=\": \"==\",\n            \"===\": \"!==\",\n            \"!==\": \"===\",\n            \"<\": \">=\",\n            \"<=\": \">\",\n            \">\": \"<=\",\n            \">=\": \"<\"\n          };\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          let pathToNegate = selectedPath.find(p => {\n            const parentPath = p.parentPath;\n\n            if (!parentPath) {\n              return false;\n            }\n\n            if (parentPath.isIfStatement() && p.parentKey === 'test') {\n              return true;\n            }\n\n            if (p.isBinaryExpression() && negatableBinaryOperators[p.node.operator]) {\n              return true;\n            }\n\n            return false;\n          });\n\n          pathToNegate = pathToNegate || selectedPath.find(p => {\n            const parentPath = p.parentPath;\n            return parentPath && parentPath.isVariableDeclarator() && p.parentKey === 'init';\n          });\n\n          if (!pathToNegate) {\n            lively.warn('not within a negatable node');\n            exitedEarly = true;\n            return;\n          }\n\n          pathLocationsToSelect.push(pathToNegate.getPathLocation());\n\n          if (pathToNegate.isUnaryExpression() && pathToNegate.node.operator === '!') {\n            pathToNegate.replaceWith(pathToNegate.get('argument').node);\n          } else {\n            const negatedOperator = negatableBinaryOperators[pathToNegate.node.operator];\n            if (pathToNegate.isBinaryExpression() && negatedOperator) {\n              pathToNegate.node.operator = negatedOperator;\n            } else {\n              pathToNegate.replaceWith(t.unaryExpression(\"!\", pathToNegate.node));\n            }\n          }\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  insertMarkdownComment() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    const before = '/*MD ## ';\n    const around = 'your text';\n    const after = ' MD*/';\n    const l4url = 'lively4url';\n    const l4urlplus = l4url + ' + ';\n\n    const selections = cm.getSelections();\n    cm.replaceSelections(selections.fill(before));\n    cm.replaceSelections(selections.fill(after), \"start\");\n    cm.replaceSelections(selections.fill(around), \"around\");\n  }\n  braveNewWorld() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    this.highlightChanges();\n  }\n\n  highlightChanges() {\n    const from = document.querySelector('#from').editor;\n    const to = document.querySelector('#to').editor;\n    const targetLCM = document.querySelector('#target');\n    const targetCM = targetLCM.editor;\n    const oldText = from.getValue();\n    const newText = to.getValue();\n\n    targetLCM.value = oldText;\n\n    var dmp = new diff.diff_match_patch();\n    var d = dmp.diff_main(oldText, newText);\n    // d.inspect()\n    var index = 0;\n    let firstChangeStep = true;\n    // prune diffs\n    const onlySpaces = str => str.trim().length === 0;\n    // d = d.filter(([changeType, text]) => changeType === 0 || !onlySpaces(text));\n    // d.inspect()\n    for (let [changeType, text] of d) {\n      index = this.highlightChange(changeType, targetCM, text, index);\n      firstChangeStep = false;\n    }\n  }\n\n  highlightChange(changeType, cm, text, index) {\n    switch (changeType) {\n      case DMP_EQUALITY:\n        index += text.length;\n        break;\n      case DMP_INSERTION:\n        cm.replaceRange(text, cm.posFromIndex(index), cm.posFromIndex(index), 'insertion');\n        index += text.length;\n        break;\n      case DMP_DELETION:\n        cm.replaceRange('', cm.posFromIndex(index), cm.posFromIndex(index + text.length), 'deletion');\n        break;\n    }\n\n    return index;\n  }\n\n  /*MD ## Slurping and Barfing MD*/\n  slurpOrBarf({ slurp = false, barf = false, forward }) {\n    const cm = this.codeProvider.codeMirror;\n    var getScrollInfo = () => {\n      return cm.getScrollInfo();\n    };\n\n    var setScrollInfo = scrollInfo => {\n      cm.scrollIntoView({\n        left: scrollInfo.left,\n        top: scrollInfo.top,\n        right: scrollInfo.left + scrollInfo.width,\n        bottom: scrollInfo.top + scrollInfo.height\n      });\n    };\n\n    const scrollInfo = getScrollInfo();\n    const selections = cm.listSelections();\n\n    const res = this.sourceCode.transformAsAST(({ types: t }) => ({\n      visitor: {\n        Program: programPath => {\n          let path = this.getInnermostPathContainingSelection(programPath, range(selections.first));\n          let innerBlock = path.find(p => {\n\n            if (!p.isBlock()) {\n              return false;\n            }\n            if (barf && p.get('body').length === 0) {\n              // nothing to barf\n              return false;\n            }\n            return true;\n          });\n          \n          if (!innerBlock) {\n            if (barf) {\n              lively.warn('nothing to barf');\n            } else {\n              lively.warn('no innerBlock found');\n            }\n            return;\n          }\n          \n          let outerStatement = innerBlock.find(p => {\n            if (!(p.parentPath && p.parentPath.isBlock())) {\n              return false;\n            }\n            if (slurp) {\n              if (forward && !p.getNextSibling().node) {\n                return false;\n              }\n              if (!forward && !p.getPrevSibling().node) {\n                return false;\n              }\n            }\n            return true;\n          });\n\n          if (slurp) {\n            if (forward) {\n              const pathToSlurp = outerStatement.getNextSibling();\n              innerBlock.pushContainer('body', pathToSlurp.node);\n              pathToSlurp.remove();\n            } else {\n              const pathToSlurp = outerStatement.getPrevSibling();\n              innerBlock.unshiftContainer('body', pathToSlurp.node);\n              pathToSlurp.remove();\n            }\n          }\n          if (barf) {\n            if (forward) {\n              const pathToBarf = innerBlock.get('body').last;\n              outerStatement.insertAfter(pathToBarf.node);\n              pathToBarf.remove();\n            } else {\n              const pathToBarf = innerBlock.get('body').first;\n              outerStatement.insertBefore(pathToBarf.node);\n              pathToBarf.remove();\n            }\n          }\n        }\n      }\n    }));\n\n    this.sourceCode = res.code;\n\n    cm.setSelections(selections);\n    setScrollInfo(scrollInfo);\n  }\n\n  slurp(forward) {\n    this.slurpOrBarf({ slurp: true, forward });\n  }\n\n  barf(forward) {\n    this.slurpOrBarf({ barf: true, forward });\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  /**\n   * Invalidates old state on code change\n  */\n  codeChanged() {\n    this.myProgramPath = undefined;\n    this.parsingFailed = null;\n    this.finishedEnrichment = false;\n    this.memberAssignments = new Map();\n    this.aexprs = undefined;\n  }\n\n  get canParse() {\n    if (this.parsingFailed == null) this.programPath;\n    return !this.parsingFailed;\n  }\n\n  /** \n   * Return first child in depth first search that satisfies a condition\n   */\n  nextPath(startingPath, isValid) {\n    let pathToShow;\n\n    startingPath.traverse({\n      enter(path) {\n        if (!pathToShow && isValid(path)) {\n          pathToShow = path;\n          path.stop();\n        }\n      }\n    });\n\n    return pathToShow;\n  }\n\n  /**\n   * Return the last valid path that is generated by a given callback function on the previous path\n   */\n  getLastPath(startingPath, nextPathCallback) {\n    let pathToShow = startingPath;\n    while (true) {\n      let nextPath = nextPathCallback(pathToShow);\n      if (nextPath) {\n        pathToShow = nextPath;\n      } else {\n        break;\n      }\n    }\n\n    return pathToShow;\n  }\n\n  /**\n   * Returns the first child of a node or the node itself, if it has no children\n   */\n  getFirstChildOrSelf(startingPath) {\n    let child;\n    startingPath.traverse({\n      enter(path) {\n        if (!child) {\n          child = path;\n        }\n      }\n    });\n    return child || startingPath;\n  }\n\n  /**\n  * Returns the nearest path before the cursor location\n  */\n  getPathBeforeCursor(startingPath, anchor) {\n    const selectionStart = loc(anchor);\n    let foundPath;\n    startingPath.traverse({\n      exit(path) {\n        const pathLocation = path.node.loc;\n        const pathEnd = loc(pathLocation.end);\n        if (selectionStart.isBefore(pathEnd)) {\n          path.stop();\n          return;\n        }\n        foundPath = path;\n      }\n    });\n    return foundPath;\n  }\n\n  /**\n   * Returns the innermost node, that contains the selected text.\n   */\n  getInnermostPathContainingSelection(startingPath, selection) {\n    // go down to minimal selected node\n    const nextPathContainingCursor = (newStartingPath, selection) => {\n      return this.nextPath(newStartingPath, path => {\n        return range(path.node.loc).containsRange(selection);\n      });\n    };\n    return this.getLastPath(startingPath, prevPath => nextPathContainingCursor(prevPath, selection));\n  }\n\n  getSelectedPaths(programPath) {\n    return this.selectionRanges.map(selection => {\n      const pathContainingWholeSelection = this.getInnermostPathContainingSelection(programPath, selection);\n\n      //path already matches the selection\n      if (this.isPathExactlySelected(pathContainingWholeSelection, selection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        enter(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedStatements(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isStatement(pathContainingWholeSelection) && !t.isBlockStatement(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Statement(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedExpressions(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isExpression(pathContainingWholeSelection) && !t.isIdentifier(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Expression(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc)) && !t.isIdentifier(path)) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  /** \n   * Takes the outermost node which 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  /**\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  /**\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    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  /**\n   * Returns all bindings of a given identifier\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  /**\n   * Returns bindings of given identifier in its class\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 (getUnbound || t.isThisExpression(path.parent.object)) {\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(conditionFunc, 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 (conditionFunc(path, pathList[i])) {\n        return pathList[i];\n      }\n    }\n    return pathList[pathList.length - 1];\n  }\n\n  /** \n   * Select the text corresponding to the given nodes\n   */\n  selectNodes(nodes, selectStringContentsOnly = false) {\n    const ranges = nodes.map(node => {\n      let selectedRange = range(node.loc);\n      if (selectStringContentsOnly) {\n        //only select the contents, not the quotes around it \n        selectedRange.start._cmCharacter++;\n        selectedRange.end._cmCharacter--;\n      }\n      return selectedRange;\n    });\n    this.codeProvider.selections = ranges;\n  }\n\n  /** \n   * Select the text corresponding to the given paths\n   */\n  selectPaths(paths, selectStringContentsOnly = false) {\n    this.selectNodes(paths.map(path => path.node), selectStringContentsOnly);\n  }\n\n  /** \n   * Get the path for the first method with the given name\n   */\n  getMethodPath(programPath, name) {\n    let methodPath;\n    programPath.traverse({\n      ClassMethod(path) {\n        if (!methodPath && path.node.key.name == name) {\n          methodPath = path;\n        }\n      },\n      FunctionDeclaration(path) {\n        if (!methodPath && path.node.id.name == name) {\n          methodPath = path;\n        }\n      }\n    });\n    return methodPath;\n  }\n\n  /** \n   * Get the path of the first class\n   */\n  getClassPath(programPath) {\n    let classPath;\n    programPath.traverse({\n      ClassDeclaration(path) {\n        if (!classPath) {\n          classPath = path;\n        }\n      }\n    });\n    return classPath;\n  }\n\n  getColorLiterals() {\n    var pPath = this.programPath;\n    if (!pPath) return;\n    let colorPaths = [];\n    const colorRegex = /(0[xX]|#)[0-9a-fA-F]{6}$/g;\n    pPath.traverse({\n      StringLiteral(path) {\n        if (path.node.value.match(colorRegex)) {\n          colorPaths.push(path);\n        }\n      }\n    });\n    return colorPaths;\n  }\n\n  /*MD ### Shortcuts MD*/\n\n  expandSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      // go up again\n      return pathToShow.find(path => {\n        return range(path.node.loc).strictlyContainsRange(selection);\n      }) || pathToShow;\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  reduceSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      return this.getFirstChildOrSelf(pathToShow);\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  selectNextASTChild(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => {\n      return t.isIdentifier(nextNode) || t.isLiteral(nextNode) || t.isThisExpression(nextNode) || t.isSuper(nextNode) || t.isDebuggerStatement(nextNode);\n    }, reversed);\n  }\n\n  selectNextASTNodeLikeThis(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => currentNode.type == nextNode.type, reversed);\n  }\n\n  selectNextReference(reversed) {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);if (bindings) {\n      let sortedBindings = [...bindings].sort((a, b) => a.node.start - b.node.start);\n      let index = sortedBindings.indexOf(selectedPath);\n      index += reversed ? -1 : 1;\n      index = (index + sortedBindings.length) % sortedBindings.length;\n      this.selectPaths([sortedBindings[index]]);\n    }\n  }\n\n  async selectDeclaration() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) {\n      return;\n    }\n    const identName = identifier.node.name;\n\n    const declaration = await this.getDeclaration(identifier);\n    //needs smarter selection of source\n    if (declaration && !t.isImportSpecifier(declaration)) {\n      this.selectPaths([declaration]);\n    } else {\n      let classPath = this.getClassPath(this.programPath);\n      let methodPath = this.getMethodPath(classPath, identName);\n      if (methodPath) {\n        this.selectNodes([methodPath.node.key]);\n      } else {\n\n        // Find the declaration in other files and open the possible files in a new browser at the correct location\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 there is a binding in the current AST, all references get selected for renaming\n    if (astBindings) {\n      this.selectPaths(astBindings);\n      return;\n    }\n\n    /**\n     * If not: the user gets a list of all possible occurrences and can select entries for renaming and can choose the new name.\n     * Afterwards the selected occurrences in other files get refactored in the background.\n     */\n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\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  /**\n   * Uses the FileIndex to look for possible bindings in other files and returns an array containing elements with the name of found files, their urls and the line and column of the occurrence.\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  // returns a parentPath if path is somewhere in a path with a type stored in type\n  // or null if no type matches\n  // type can be a single type string or an array of type strings\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  // returns if path is directly in a path with a type stored in type\n  // type can be a single type string or an array of type strings \n  isDirectlyIn(type, path) {\n    if (type instanceof Array) {\n      return type.map(elem => this.isDirectlyIn(elem, path)).reduce((accu, elem) => accu || elem, false);\n    }\n    return path.node && path.node.type === type;\n  }\n\n  /*MD ## Color Picker MD*/\n\n  updateColor(currentLocation, color) {\n    var location = { anchor: currentLocation, head: currentLocation };\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.getInnermostPathContainingSelection(programPath, range(location)); //this.getPathBeforeCursor(programPath, currentLocation);\n          if (t.isStringLiteral(path.node)) {\n            path.node.value = color;\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n  }\n  /*MD ## Generations MD*/\n\n  /*MD ### Generate Testcase / Class / get / set / HTML accessors MD*/\n\n  async openHTMLAccessorsMenu(ids, initialSelectionState) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"Select HTML Accessors to generate\");\n    return comp.selectItems(ids, initialSelectionState);\n  }\n\n  getExistingAccessors() {\n    let classMethodIdentifier = [];\n    this.programPath.traverse({\n      ExportDefaultDeclaration(path) {\n        if (path && path.node.declaration && path.node.declaration.type == \"ClassDeclaration\") {\n          classMethodIdentifier = path.node.declaration.body.body.map(elem => elem.key.name);\n          path.stop();\n        }\n      }\n    });\n    return classMethodIdentifier;\n  }\n\n  async generateHTMLAccessors() {\n    const ids = await this.compileListOfIDs();\n    if (ids.length === 0) {\n      return;\n    }\n\n    let existingMethods = this.getExistingAccessors();\n    let initialSelectionState = ids.map(elem => existingMethods.includes(this.generateMethodNameFromProperty(elem.id)));\n    const selectedItems = await this.openHTMLAccessorsMenu(ids, initialSelectionState);\n\n    if (selectedItems.length === 0) {\n      return;\n    }\n    lively.warn(`${selectedItems.length} Accessors generated`);\n\n    selectedItems.forEach(item => {\n      this.generateCodeFragment(item.id, name => this.compileHTMLGetter(name));\n      const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n      let line = selectedPath.parent.loc.end.line + 1;\n      this.codeProvider.cursor = loc({ line, ch: 0 });\n    });\n  }\n\n  // collects all html element ids of the current file\n  async compileListOfIDs() {\n    const htmlURI = this.codeProvider.htmlURI;\n    let html = await htmlURI.fetchText();\n\n    if (html === \"File not found!\\n\") {\n      lively.warn(\"There is no HTML associated with this file.\");\n      return [];\n    }\n\n    let tmp = <div></div>;\n    tmp.innerHTML = html;\n    let ids = tmp.childNodes[0].content.querySelectorAll(\"[id]\").map(ea => ea.id);\n\n    const htmlLines = html.split(\"\\n\");\n\n    const idsWithLocation = [];\n    for (const id of ids) {\n      for (const line of htmlLines) {\n        const indexOfId = line.indexOf(\"id=\\\"\" + id + \"\\\"\");\n        if (indexOfId !== -1) {\n          idsWithLocation.push({ id, url: htmlURI, line: htmlLines.indexOf(line), ch: indexOfId + 4 });\n          break;\n        }\n      }\n    }\n    return idsWithLocation;\n  }\n\n  generateTestCase() {\n    this.generateCodeFragment(\"ExplainWhatIsTested\", id => this.compileTestCase(id.identifier));\n  }\n\n  generateGetter() {\n    this.generateCodeFragment(\"NameThisGetter\", id => this.compileGetter(id.identifier));\n  }\n\n  generateSetter() {\n    this.generateCodeFragment(\"NameThisSetter\", id => this.compileSetter(id.identifier));\n  }\n\n  generateClass() {\n    this.generateCodeFragment(\"SetClassName\", id => this.compileClass(id.identifier));\n  }\n\n  async generateCodeFragment(identifier, replacementGenerator) {\n    const scrollInfo = this.scrollInfo;\n    const selection = this.firstSelection;\n\n    var identifierObject = { identifier };\n\n    var generatedCode;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let pathBefore = this.getPathBeforeCursor(programPath, selection.start);\n          let pathWithin = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n          generatedCode = replacementGenerator(identifierObject);\n          if (pathBefore === undefined) {\n            // we're on top of the program\n            pathWithin.unshiftContainer('body', generatedCode);\n          } else if (this.isDirectlyIn(pathWithin.type, pathBefore.parentPath)) {\n            // we're inside of a code block, but not in the first line\n            pathBefore.insertAfter(generatedCode);\n          } else {\n            // we're in the first line of a block\n            pathWithin.unshiftContainer('body', generatedCode);\n          }\n        }\n      }\n    })).code;\n\n    // after code generation, we have to find the generated code another time to be able to select it for renaming\n    var pathToSelect;\n    this.programPath.traverse({\n      StringLiteral(path) {\n        if (!pathToSelect && path.node.value == identifierObject.identifier) {\n          pathToSelect = path;\n        }\n      },\n      Identifier(path) {\n        if (path.node.name == identifierObject.identifier) {\n          pathToSelect = path;\n          path.stop();\n        }\n      }\n    });\n    this.selectPaths([pathToSelect], true);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  compileTestCase(explanation) {\n    return template(\"it(EXP, () => {\\n\" + \"let put = 'code here';\" + \"})\")({\n      EXP: t.stringLiteral(explanation)\n    });\n  }\n\n  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  /*MD ### Generate Import MD*/\n\n  /**\n   * Converts the selected expression to a member expression and adds an import to the file if it doesn't already exist.\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 proper 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 extraction = this.selectMethodExtraction(programPath);\n          if (!extraction) return;\n          const {\n            selectedPaths,\n            extractingExpression,\n            actualSelections\n          } = extraction;\n\n          const identifiers = selectedPaths.map(this.getAllIdentifiers).flat();\n          let surroundingMethod = selectedPaths[0].find(parent => {\n            return parent.node.type == \"ClassMethod\";\n          });\n          var shouldBeStatic = this.couldBeStatic(selectedPaths);\n          if (!surroundingMethod) {\n            surroundingMethod = selectedPaths[selectedPaths.length - 1];\n          } else {\n            shouldBeStatic = surroundingMethod.node.static;\n          }\n          const shouldBeAsync = this.shouldBeAsync(selectedPaths);\n          const parameters = this.findParameters(identifiers, surroundingMethod, actualSelections);\n          const returnValues = this.findReturnValues(identifiers, surroundingMethod, actualSelections);\n          this.createMethod(selectedPaths, [...new Set(parameters)], returnValues, surroundingMethod, extractingExpression, shouldBeAsync, shouldBeStatic);\n        }\n      }\n    }));\n    this.sourceCode = transformed.code;\n    this.scrollTo(scrollInfo);\n    const pathsToSelect = [];\n    this.programPath.traverse({\n      Identifier(path) {\n        if (path.node.name == \"HopefullyNobodyEverUsesThisMethodName\") {\n          pathsToSelect.push(path);\n        }\n      }\n    });\n    this.selectPaths(pathsToSelect);\n  }\n\n  /*MD ### Extract Variable MD*/\n\n  selectMethodExtraction(programPath, silent = false) {\n    var selectedPaths = this.getSelectedStatements(programPath);\n    var extractingExpression = false;\n\n    if (selectedPaths.length == 0) {\n      var expressions = this.getSelectedExpressions(programPath);\n      if (expressions.length > 1) {\n        if (!silent) lively.warn('You cannot extract multiple statements at once. Select statements or a single expression!');\n        return;\n      } else if (expressions.length == 0) {\n        if (!silent) lively.warn('Select statements or an expression to extract!');\n        return;\n      } else {\n        selectedPaths = expressions;\n        extractingExpression = true;\n      }\n    }\n\n    const actualSelections = selectedPaths.map(path => {\n      return range(path.node.loc);\n    });\n    return {\n      selectedPaths,\n      extractingExpression,\n      actualSelections\n    };\n  }\n\n  async extractExpressionIntoLocalVariable() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(({ types: t }) => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n\n              path.find(p => {\n                const parentPath = p.parentPath;\n                if (!parentPath) {\n                  return false;\n                }\n\n                function ensureBlock(body) {\n                  if (!body.node) return false;\n\n                  if (body.isBlockStatement()) {\n                    return false;\n                  }\n\n                  const statements = [];\n                  if (body.isStatement()) {\n                    statements.push(body.node);\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else if (body.parentPath.isArrowFunctionExpression() && body.isExpression()) {\n                    statements.push(t.returnStatement(body.node));\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else {\n                    throw new Error(\"I never thought this was even possible.\");\n                  }\n                }\n\n                const targetLocation = path.getPathLocation();\n                const blockLocation = p.getPathLocation();\n                if (p.parentKey === 'body' && (parentPath.isFor() || parentPath.isWhile())) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if (p.parentKey === 'body' && parentPath.isFunction()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0].argument' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if ((p.parentKey === 'consequent' || p.parentKey === 'alternate') && parentPath.isIfStatement()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n              });\n\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No Expression to extract found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          let value = '';\n          path.traverse({\n            Identifier(p) {\n              value += '-' + p.node.name;\n            }\n          });\n          if (value.length > 0) {\n            // #TODO: ensure unique identifier\n            value = value.camelCase();\n          } else {\n            value = path.scope.generateUidIdentifier('temp').name;\n          }\n          const identifier = t.Identifier(value);\n          const decl = template('const ID = INIT;')({\n            ID: identifier,\n            INIT: path.node\n          });\n\n          let referree = t.Identifier(value);\n\n          path.replaceWith(referree);\n          const insertedDeclaration = path.getStatementParent().insertBefore(decl)[0];\n          const insertedDeclarationIdentifier = insertedDeclaration.get('declarations')[0].get('id');\n\n          pathLocationsToSelect.push(insertedDeclarationIdentifier.getPathLocation());\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.scrollTo(scrollInfo);\n  }\n\n  async inlineLocalVariable(foo) {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n    debugger;\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const identifier = this.getFirstSelectedIdentifier(selectedPath);\n          if (!identifier) {\n            lively.warn('no identifier selected');\n            exitedEarly = true;\n            return;\n          }\n\n          const name = identifier.node.name;\n          if (!identifier.scope.hasBinding(name)) {\n            lively.warn('no binding found for ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          let binding = identifier.scope.getBinding(name);\n          if (!binding) {\n            lively.warn('selected identifier is not referencing a variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          if (!['var', 'let', 'const'].includes(binding.kind)) {\n            lively.warn('binding for \"' + name + '\" is of kind \"' + binding.kind + '\" but should be any of \"var\", \"let\", or \"const\"');\n            exitedEarly = true;\n            return;\n          }\n\n          const constantViolations = binding.constantViolations.map(cv => this.getFirstSelectedIdentifierWithName(cv, binding.identifier.name));\n          if (constantViolations.length > 0) {\n            lively.warn('cannot inline because there is a constant violation for variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          const declarationIdentifierPath = this.getBindingDeclarationIdentifierPath(binding);\n          if (!declarationIdentifierPath.parentPath.isVariableDeclarator()) {\n            lively.warn('declaration is probably in a destructuring');\n            exitedEarly = true;\n            return;\n          }\n\n          const referencePaths = binding.referencePaths;\n          if (referencePaths.length === 0) {\n            lively.warn('variable \"' + name + '\" is never referenced');\n            exitedEarly = true;\n            return;\n          }\n\n          const identifierPaths = [declarationIdentifierPath, ...referencePaths, ...constantViolations];\n          if (!identifierPaths.includes(identifier)) {\n            lively.warn('selected identifier is not referencing a variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          const variableDeclarator = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclarator());\n          const variableDeclaration = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclaration());\n          const initPath = variableDeclarator.get('init');\n\n          // remove declaration\n          if (variableDeclaration.get('declarations').length === 1) {\n            variableDeclaration.remove();\n          } else {\n            variableDeclarator.remove();\n          }\n\n          // inline declaration\n          referencePaths.forEach(p => {\n            pathLocationsToSelect.push(p.getPathLocation());\n          });\n          referencePaths.forEach(p => {\n            p.replaceWith(initPath.node);\n          });\n          const o = { a: 42, b: 17 };\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  async wrapExpressionIntoActiveExpression() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No `Expression` to wrap found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          const ae = template('aexpr(() => EXPR)')({\n            EXPR: path.node\n          }).expression;\n\n          path.replaceWith(ae);\n\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Accessors MD*/\n\n  get sourceCode() {\n    return this.codeProvider.code;\n  }\n  set sourceCode(text) {\n    this.codeProvider.code = text;\n    this.codeChanged();\n    return this.codeProvider.code;\n  }\n\n  get scrollInfo() {\n    return this.codeProvider.scrollInfo;\n  }\n\n  scrollTo(scrollInfo) {\n    this.codeProvider.scrollInfo = scrollInfo;\n  }\n\n  /*MD ## Utilities MD*/\n\n  isSelected(path, selections = null) {\n    if (!selections) {\n      selections = this.selectionRanges;\n    }\n    const pathRange = range(path.node.loc);\n    for (const selection of selections) {\n      if (selection.containsRange(pathRange)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  isPathExactlySelected(path, selection) {\n    return selection.isEqual(range(path.node.loc));\n  }\n\n  pathByLocationFromProgram(programPath, location) {\n    let path = programPath;\n    const reg = /(\\.[A-Za-z0-9]+|(\\[[0-9]+\\]))/ig;\n    let result;\n    while ((result = reg.exec(location)) !== null) {\n      let part = result[0];\n      if (part.startsWith('.')) {\n        part = part.replace('.', '');\n        path = path.get(part);\n      } else {\n        part = part.replace(/\\[|\\]/ig, '');\n        part = parseInt(part);\n        path = path[part];\n      }\n    }\n\n    return path;\n  }\n\n  pathLocationsToPathes(pathLocations) {\n    const paths = [];\n\n    this.sourceCode.traverseAsAST({\n      Program: path => {\n        pathLocations.forEach(location => {\n          paths.push(this.pathByLocationFromProgram(path, location));\n        });\n      }\n    });\n\n    return paths;\n  }\n\n  async getCorrespondingClasses(methodName) {\n    let index = await FileIndex.current();\n\n    //find classes that contain the method\n    let possibleClasses = await index.db.classes.filter(cl => {\n      return cl.methods.some(me => me.name == methodName);\n    }).toArray();\n\n    //find files that export things with the urls from the found classes\n    let possibleExports = await index.db.exports.where('url').anyOf(possibleClasses.map(cl => cl.url)).toArray();\n\n    //reduce the found classes with the found possible exports\n    let locations = possibleClasses.filter(cl => {\n      return possibleExports.some(e => e.url == cl.url && e.classes.some(eCl => eCl == cl.name));\n    });\n    return locations.filter(ea => ea.url.match(lively4url)); //filter local files\n  }\n\n  async getFunctionExportURLs(methodName) {\n    let index = await FileIndex.current();\n    let locations = await index.db.exports.filter(exp => {\n      return exp.functions.some(me => me == methodName);\n    }).toArray();\n    return locations.map(loc => loc.url).filter(url => url.match(lively4url));\n  }\n}"]}