{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-bp2019/src/components/widgets/lively-code-mirror-ast-capabilities.js"],"names":["loc","range","fileEnding","replaceFileEndingWith","boundEval","ContextMenu","FileIndex","babelDefault","babel","t","types","template","ASTCapabilities","constructor","livelyCodeMirror","codeMirror","editor","selectionRanges","listSelections","length","firstSelection","map","_getFirstSelectionOrCursorPosition","anchor","getCursor","head","programPath","myProgramPath","programPathFor","sourceCode","code","traverseAsAST","Program","path","err","codeChanged","undefined","updateColorPicker","nextPath","startingPath","isValid","pathToShow","traverse","enter","stop","getLastPath","nextPathCallback","getFirstChildOrSelf","child","getPathBeforeCursor","selectionStart","foundPath","exit","pathLocation","node","pathEnd","end","isBefore","getInnermostPathContainingSelection","selection","nextPathContainingCursor","newStartingPath","containsRange","prevPath","getSelectedPaths","pathContainingWholeSelection","isPathExactlySelected","selectedPaths","containsPartsOfRange","push","skip","flat","getSelectedStatements","getOutermostPathContainingSelectionWithMinimalSelectionRange","isStatement","isBlockStatement","Statement","getSelectedExpressions","isExpression","isIdentifier","Expression","currentPath","findParent","isEqual","forwardList","parentPath","linearizedPathList","backwardList","reverse","selectNextASTNodeWith","condition","reversed","pathList","maxPaths","getNextASTNodeInListWith","selectPaths","getFirstSelectedIdentifier","startPath","first","Identifier","getFirstSelectedIdentifierWithName","name","getAllIdentifiers","identifiers","getDeclaration","identifier","scope","hasBinding","getBinding","getBindingDeclarationIdentifierPath","binding","getBindingsInFile","astBindings","getASTBinding","getClassBindings","identifierPaths","Set","referencePaths","constantViolations","cv","includes","isMemberExpression","parent","isThisExpression","object","classPath","getClassPath","methodPath","getMethodPath","getClassMethodBindings","getMemberBindings","isClassMethod","classMethod","methodIdentifier","getUnbound","members","getAllUnboundIdentifierNames","unboundIdentifiers","filter","value","index","self","indexOf","currentPathInList","find","pathInList","currentIndex","i","selectNodes","nodes","selectStringContentsOnly","ranges","asCM","isStringLiteral","ch","setSelection","setSelections","scrollIntoView","from","to","paths","ClassMethod","key","FunctionDeclaration","id","ClassDeclaration","getColorLiterals","colorPaths","colorRegex","StringLiteral","match","expandSelection","strictlyContainsRange","reduceSelection","selectNextASTChild","currentNode","nextNode","isLiteral","isSuper","isDebuggerStatement","selectNextASTNodeLikeThis","type","selectNextReference","selectedPath","bindings","sortedBindings","sort","a","b","start","selectDeclaration","identName","declaration","isImportSpecifier","classUrls","getCorrespondingClasses","then","arr","cl","url","functionUrls","getFunctionExportURLs","urls","concat","forEach","lively","openBrowser","container","asyncGet","livelyEditor","newCodeMirror","cm","awaitEditor","astCapabilities","ac","rename","bindingItems","getPossibleBindingsAcrossFiles","comp","openComponentInWindow","focus","setAdditionalInput","setTitle","references","selectItems","newName","getAdditionalInput","camelCase","reference","fetch","r","text","codeLines","split","String","prototype","replaceBetween","what","substring","line","newCode","join","files","saveFile","reloadModule","System","import","selectBindings","printAllBindings","openReferencesMenu","current","ids","db","file","some","toArray","program","column","lastIndexOf","identifierName","findImports","functions","classes","isInDescribe","possiblePath","isIn","callee","isDirectlyIn","Array","elem","reduce","accu","openMenu","fa","modifiers","m","myself","generateGenerationSubmenu","submenu","menu","remove","generateClass","unshift","generateTestCase","generateGetter","generateSetter","generateImportSubmenu","replace","lively4url","addImport","menuItems","extractExpressionIntoLocalVariable","wrapExpressionIntoActiveExpression","extractMethod","selectMethodExtraction","changedSelectionInMenu","undoSelection","generateHTMLAccessors","menuPosition","cursorCoords","openIn","document","body","clientX","left","clientY","bottom","addEventListener","focusEditor","openHTMLAccessorsMenu","initialSelectionState","getExistingAccessors","classMethodIdentifier","ExportDefaultDeclaration","compileListOfIDs","existingMethods","generateMethodNameFromProperty","selectedItems","warn","item","generateCodeFragment","compileHTMLGetter","allParents","ele","tagName","jsURI","encodeURI","shadowRoot","querySelector","htmlURI","html","fetchText","tmp","innerHTML","childNodes","content","querySelectorAll","ea","htmlLines","idsWithLocation","indexOfId","compileTestCase","compileGetter","compileSetter","compileClass","replacementGenerator","scrollInfo","identifierObject","generatedCode","transformAsAST","visitor","pathBefore","pathWithin","unshiftContainer","insertAfter","pathToSelect","scrollTo","explanation","EXP","stringLiteral","propertyName","blockStatement","returnStatement","memberExpression","thisExpression","expressionStatement","assignmentExpression","className","classDeclaration","classBody","property","methodName","callExpression","getUserInput","description","defaultValue","input","prompt","Promise","resolve","reject","importName","isFunction","existingImportStatement","isImportDeclaration","source","importStatement","importDeclaration","importSpecifier","specifiers","spec","imported","replaceWith","findParameters","surroundingMethod","actualSelections","needsToBeParameter","bindingPath","isSelected","shouldBeAsync","hasAwait","isAwaitExpression","AwaitExpression","couldBeStatic","hasThis","ThisExpression","findReturnValues","declarationInSelection","constantViolationInSelection","constantViolation","referenceOutsideSelection","needsToBeReturned","constantViolationOutsideSelection","declaredInExtractedCode","createMethod","parameter","returnValues","extractingExpression","shouldBeStatic","returnValue","returnIdentifier","objectExpression","objectProperty","methodContent","p","newMethod","async","static","methodCall","awaitExpression","variableType","variableDeclaration","variableDeclarator","objectPattern","replaceWithMultiple","transformed","parameters","pathsToSelect","silent","expressions","done","pathLocationToBeExtracted","res","isSelectedPath","getPathLocation","ensureBlock","statements","blockNode","isArrowFunctionExpression","Error","targetLocation","blockLocation","parentKey","isFor","isWhile","becameABlock","isIfStatement","pathLocationsToSelect","resultExtracted","pathByLocationFromProgram","generateUidIdentifier","decl","ID","INIT","referree","insertedDeclaration","getStatementParent","insertBefore","insertedDeclarationIdentifier","get","pathLocationsToPathes","ae","EXPR","expression","getScrollInfo","top","right","width","height","selections","pathRange","location","reg","result","exec","part","startsWith","parseInt","pathLocations","possibleClasses","methods","me","possibleExports","exports","where","anyOf","locations","e","eCl","exp","pPath","old","getAllMarks","marker","clear","colorLiterals","picker","createElement","bookmark","setBookmark","event","currentLocation","updateColor","target","color"],"mappings":"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","file":"lively-code-mirror-ast-capabilities.js","sourcesContent":["import { loc, range } from 'utils';\n\nimport boundEval from 'src/client/bound-eval.js';\nimport ContextMenu from 'src/client/contextmenu.js';\nimport FileIndex from \"src/client/fileindex.js\";\n\nimport babelDefault from 'systemjs-babel-build';\nconst babel = babelDefault.babel;\n\nconst t = babel.types;\nconst template = babel.template;\n\nimport { fileEnding, replaceFileEndingWith } from \"utils\";\n\nexport default class ASTCapabilities {\n\n  constructor(livelyCodeMirror, codeMirror) {\n    this.livelyCodeMirror = livelyCodeMirror;\n    this.codeMirror = codeMirror;\n  }\n  get editor() {\n    return this.codeMirror;\n  }\n  get selectionRanges() {\n    if (this.editor.listSelections().length == 0) {\n      return this.firstSelection;\n    }\n    return this.editor.listSelections().map(range);\n  }\n\n  get firstSelection() {\n    return range(this._getFirstSelectionOrCursorPosition());\n  }\n\n  _getFirstSelectionOrCursorPosition() {\n    if (this.editor.listSelections().length == 0) {\n      return { anchor: this.editor.getCursor(), head: this.editor.getCursor() };\n    }\n    return this.editor.listSelections()[0];\n  }\n\n  /*MD ## Navigation MD*/\n  /**\n   * Get the root path\n  */\n  get programPath() {\n    if (!this.myProgramPath) {\n      this.myProgramPath = this.programPathFor(this.sourceCode);\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 null;\n    }\n\n    return programPath;\n  }\n\n  codeChanged() {\n    this.myProgramPath = undefined;\n    this.updateColorPicker();\n  }\n\n  /** \n   * Return first child in depth first search that satisfies a condition\n   */\n  nextPath(startingPath, isValid) {\n    let pathToShow;\n\n    startingPath.traverse({\n      enter(path) {\n        if (!pathToShow && isValid(path)) {\n          pathToShow = path;\n          path.stop();\n        }\n      }\n    });\n\n    return pathToShow;\n  }\n\n  /**\n   * Return the last valid path that is generated by a given callback function on the previous path\n   */\n  getLastPath(startingPath, nextPathCallback) {\n    let pathToShow = startingPath;\n    while (true) {\n      let nextPath = nextPathCallback(pathToShow);\n      if (nextPath) {\n        pathToShow = nextPath;\n      } else {\n        break;\n      }\n    }\n\n    return pathToShow;\n  }\n\n  /**\n   * Returns the first child of a node or the node itself, if it has no children\n   */\n  getFirstChildOrSelf(startingPath) {\n    let child;\n    startingPath.traverse({\n      enter(path) {\n        if (!child) {\n          child = path;\n        }\n      }\n    });\n    return child || startingPath;\n  }\n\n  /**\n  * Returns the nearest path before the cursor location\n  */\n  getPathBeforeCursor(startingPath, anchor) {\n    const selectionStart = loc(anchor);\n    let foundPath;\n    startingPath.traverse({\n      exit(path) {\n        const pathLocation = path.node.loc;\n        const pathEnd = loc(pathLocation.end);\n        if (selectionStart.isBefore(pathEnd)) {\n          path.stop();\n          return;\n        }\n        foundPath = path;\n      }\n    });\n    return foundPath;\n  }\n\n  /**\n   * Returns the innermost node, that contains the selected text.\n   */\n  getInnermostPathContainingSelection(startingPath, selection) {\n    // go down to minimal selected node\n    const nextPathContainingCursor = (newStartingPath, selection) => {\n      return this.nextPath(newStartingPath, path => {\n        return range(path.node.loc).containsRange(selection);\n      });\n    };\n    return this.getLastPath(startingPath, prevPath => nextPathContainingCursor(prevPath, selection));\n  }\n\n  getSelectedPaths(programPath) {\n    return this.selectionRanges.map(selection => {\n      const pathContainingWholeSelection = this.getInnermostPathContainingSelection(programPath, selection);\n\n      //path already matches the selection\n      if (this.isPathExactlySelected(pathContainingWholeSelection, selection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        enter(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedStatements(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isStatement(pathContainingWholeSelection) && !t.isBlockStatement(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Statement(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedExpressions(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isExpression(pathContainingWholeSelection) && !t.isIdentifier(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Expression(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc)) && !t.isIdentifier(path)) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  /** \n   * Takes the outermost node whose corresponding selection range is minimal for containing the selected text.\n   * a      foo = bar\n   * --b    foo\n   *   --c  foo\n   * \n   * In this example, when 'foo' is selected, b will be returned, since it is the outermost node that contains the\n   * entire selection, but nothing more.\n   */\n  getOutermostPathContainingSelectionWithMinimalSelectionRange(startingPath, selection) {\n    var currentPath = this.getInnermostPathContainingSelection(startingPath, selection);\n    currentPath.findParent(path => {\n      if (selection.isEqual(range(path.node.loc))) {\n        currentPath = path;\n      }\n      return false;\n    });\n    return currentPath;\n  }\n\n  /**\n   * Array of all children in depth first search order\n   */\n  forwardList(parentPath) {\n    const linearizedPathList = [];\n    parentPath.traverse({\n      exit(path) {\n        linearizedPathList.push(path);\n      }\n    });\n    return linearizedPathList;\n  }\n  /**\n   * Array of all children in reversed depth first search order\n   */\n  backwardList(parentPath) {\n    const linearizedPathList = [];\n    parentPath.traverse({\n      enter(path) {\n        linearizedPathList.push(path);\n      }\n    });\n    return linearizedPathList.reverse();\n  }\n  /**\n   * select the selection range of the next ast node after the current selection that satisfies a given condition\n   * select previous selection instead of next, if reversed is set to true\n   */\n  selectNextASTNodeWith(condition, reversed) {\n    const programPath = this.programPath;\n    const pathList = reversed ? this.backwardList(programPath) : this.forwardList(programPath);\n\n    const maxPaths = this.selectionRanges.map(selection => {\n\n      const currentPath = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      // do we fully select the current path?\n      if (selection.isEqual(range(currentPath.node.loc))) {\n        return this.getNextASTNodeInListWith(condition, pathList, currentPath);\n      } else {\n        return currentPath;\n      }\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  getFirstSelectedIdentifier(startPath) {\n    if (t.isIdentifier(startPath.node)) {\n      return startPath;\n    }\n    var first;\n    startPath.traverse({\n      Identifier(path) {\n        if (!first) {\n          first = path;\n          path.stop();\n        }\n      }\n    });\n    return first;\n  }\n\n  getFirstSelectedIdentifierWithName(startPath, name) {\n    if (t.isIdentifier(startPath.node, { name: name })) {\n      return startPath;\n    }\n    var first;\n    startPath.traverse({\n      Identifier(path) {\n        if (!first && t.isIdentifier(path.node, { name: name })) {\n          first = path;\n          path.stop();\n        }\n      }\n    });\n    return first;\n  }\n\n  getAllIdentifiers(startPath) {\n    var identifiers = [];\n    /*if (startPath.node.type == \"Identifier\") {\n      identifiers.push(startPath);\n    }*/\n    startPath.traverse({\n      Identifier(path) {\n        identifiers.push(path);\n      }\n    });\n    return identifiers;\n  }\n\n  getDeclaration(identifier) {\n    if (identifier.scope.hasBinding(identifier.node.name)) {\n      return identifier.scope.getBinding(identifier.node.name).path;\n    }\n  }\n\n  getBindingDeclarationIdentifierPath(binding) {\n    return this.getFirstSelectedIdentifierWithName(binding.path, binding.identifier.name);\n  }\n\n  getBindingsInFile(startPath) {\n    var identifier = this.getFirstSelectedIdentifier(startPath);\n    if (!identifier) return [];\n    const astBindings = this.getASTBinding(identifier)\n\n    if(astBindings) {\n      return astBindings;\n    }\n\n    return this.getClassBindings(identifier);\n  }\n\n  getASTBinding(identifier) {\n    if (identifier.scope.hasBinding(identifier.node.name)) {\n      const binding = identifier.scope.getBinding(identifier.node.name);\n      const identifierPaths = [...new Set([this.getBindingDeclarationIdentifierPath(binding), ...binding.referencePaths, ...binding.constantViolations.map(cv => this.getFirstSelectedIdentifierWithName(cv, binding.identifier.name))])];\n      if (identifierPaths.includes(identifier)) {\n        return identifierPaths;\n      }\n    }\n    return undefined;\n  }\n\n  getClassBindings(identifier) {\n    if (t.isMemberExpression(identifier.parent)) {\n      if (t.isThisExpression(identifier.parent.object)) {\n        let classPath = this.getClassPath(this.programPath);\n        let methodPath = this.getMethodPath(classPath, identifier.node.name);\n        if (methodPath) {\n          return this.getClassMethodBindings(methodPath);\n        } else {\n          return this.getMemberBindings(identifier);\n        }\n      }\n    } else if (t.isClassMethod(identifier.parent)) {\n      return this.getClassMethodBindings(identifier.parentPath);\n    }\n  }\n\n  getClassMethodBindings(classMethod) {\n    var methodIdentifier;\n    classMethod.traverse({\n      Identifier(path) {\n        path.stop();\n        methodIdentifier = path;\n      }\n    });\n    return [methodIdentifier, ...this.getMemberBindings(methodIdentifier)];\n  }\n\n  /**\n   * if getUnbound is set to true, instead of getting all member Expressions with this (= that are bound) we only get those, that are unbound\n   */\n  getMemberBindings(identifier, getUnbound = false, startPath = this.programPath) {\n    var members = [];\n    startPath.traverse({\n      Identifier(path) {\n        if (t.isMemberExpression(path.parent) && path.node.name === identifier.node.name) {\n          if (t.isThisExpression(path.parent.object) && !getUnbound) {\n            members.push(path);\n          } else if (getUnbound) {\n            members.push(path);\n          }\n        }\n      }\n    });\n    return members;\n  }\n\n  getAllUnboundIdentifierNames(startPath = this.programPath) {\n    var unboundIdentifiers = [];\n    startPath.traverse({\n      Identifier(path) {\n        if (t.isMemberExpression(path.parent)) {\n          if (!t.isThisExpression(path.parent.object)) {\n            unboundIdentifiers.push(path);\n          }\n        }\n      }\n    });\n    return unboundIdentifiers.map(binding => binding.node.name).filter((value, index, self) => self.indexOf(value) === index);\n  }\n\n  getNextASTNodeInListWith(condition, pathList, path) {\n    const currentPathInList = pathList.find(pathInList => pathInList.node === path.node);\n    const currentIndex = pathList.indexOf(currentPathInList);\n    for (var i = currentIndex + 1; i < pathList.length; i++) {\n      if (condition(path, pathList[i])) {\n        return pathList[i];\n      }\n    }\n    return pathList[pathList.length - 1];\n  }\n\n  /** \n   * Select the text corresponding to the given nodes in the editor\n   */\n  selectNodes(nodes, selectStringContentsOnly = false) {\n    const ranges = nodes.map(node => {\n      const [anchor, head] = range(node.loc).asCM();\n      if (selectStringContentsOnly && t.isStringLiteral(node)) {\n        anchor.ch++;\n        head.ch--;\n      }\n      return { anchor, head };\n    });\n    // #TODO: include primary selection\n    if (ranges.length == 1) {\n      this.editor.setSelection(ranges[0].head, ranges[0].anchor);\n    } else {\n      this.editor.setSelections(ranges);\n    }\n    this.codeMirror.scrollIntoView({ from: ranges[0].head, to: ranges[0].anchor }, 120);\n  }\n\n  /** \n   * Select the text corresponding to the given paths in the editor\n   */\n  selectPaths(paths, selectStringContentsOnly = false) {\n    this.selectNodes(paths.map(path => path.node), selectStringContentsOnly);\n  }\n\n  /** \n   * Get the path for the first method with the given name\n   */\n  getMethodPath(programPath, name) {\n    let methodPath;\n    programPath.traverse({\n      ClassMethod(path) {\n        if (!methodPath && path.node.key.name == name) {\n          methodPath = path;\n        }\n      },\n      FunctionDeclaration(path) {\n        if (!methodPath && path.node.id.name == name) {\n          methodPath = path;\n        }\n      }\n    });\n    return methodPath;\n  }\n\n  /** \n   * Get the path of the first file\n   */\n  getClassPath(programPath) {\n    let classPath;\n    programPath.traverse({\n      ClassDeclaration(path) {\n        if (!classPath) {\n          classPath = path;\n        }\n      }\n    });\n    return classPath;\n  }\n\n  getColorLiterals(programPath) {\n    let colorPaths = [];\n    const colorRegex = /(0[xX]|#)[0-9a-fA-F]{6}$/g;\n    programPath.traverse({\n      StringLiteral(path) {\n        if (path.node.value.match(colorRegex)) {\n          colorPaths.push(path);\n        }\n      }\n    });\n    return colorPaths;\n  }\n\n  /*MD ### Shortcuts MD*/\n\n  expandSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      // go up again\n      return pathToShow.find(path => {\n        return range(path.node.loc).strictlyContainsRange(selection);\n      }) || pathToShow;\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  reduceSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      return this.getFirstChildOrSelf(pathToShow);\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  selectNextASTChild(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => {\n      return t.isIdentifier(nextNode) || t.isLiteral(nextNode) || t.isThisExpression(nextNode) || t.isSuper(nextNode) || t.isDebuggerStatement(nextNode);\n    }, reversed);\n  }\n\n  selectNextASTNodeLikeThis(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => currentNode.type == nextNode.type, reversed);\n  }\n\n  selectNextReference(reversed) {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);if (bindings) {\n      let sortedBindings = [...bindings].sort((a, b) => a.node.start - b.node.start);\n      let index = sortedBindings.indexOf(selectedPath);\n      index += reversed ? -1 : 1;\n      index = (index + sortedBindings.length) % sortedBindings.length;\n      this.selectPaths([sortedBindings[index]]);\n    }\n  }\n\n  async selectDeclaration() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) {\n      return;\n    }\n    const identName = identifier.node.name;\n\n    const declaration = await this.getDeclaration(identifier);\n    //needs smarter selection of source\n    if (declaration && !t.isImportSpecifier(declaration)) {\n      this.selectPaths([declaration]);\n    } else {\n      let classPath = this.getClassPath(this.programPath);\n      let methodPath = this.getMethodPath(classPath, identName);\n      if (methodPath) {\n        this.selectNodes([methodPath.node.key]);\n      } else {\n        const classUrls = await this.getCorrespondingClasses(identName).then(arr => arr.map(cl => cl.url));\n        const functionUrls = await this.getFunctionExportURLs(identName);\n        const urls = classUrls.concat(functionUrls);\n\n        urls.forEach(url => lively.openBrowser(url, true).then(container => {\n          container.asyncGet(\"#editor\").then(async livelyEditor => {\n            let newCodeMirror = livelyEditor.livelyCodeMirror();\n            var cm = await livelyEditor.awaitEditor();\n            newCodeMirror.astCapabilities(cm).then(ac => {\n              ac.selectPaths([ac.getMethodPath(ac.programPath, identName)]);\n            });\n          });\n        }));\n      }\n    }\n    /**\n      TODO: if our dependencies don't have the method, we can search all classes    \n      Also: do not only search for methods, but for members too (even though they are technically not bindings?)\n    */\n  }\n\n  async rename() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    var identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) return;\n    const astBindings = this.getASTBinding(identifier)\n\n    if(astBindings) {\n      this.selectPaths(astBindings);\n      return;\n    }\n    \n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\n\n    \n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setAdditionalInput(\"Name\", \"enter new name\");\n    comp.setTitle(\"Rename \" + identifier.node.name);\n    const references = await comp.selectItems(bindingItems);\n    \n    const newName = comp.getAdditionalInput().camelCase();\n    if(newName === \"\") return;\n    \n    for(const reference of references) {\n      const code = await fetch(reference.url).then(r => r.text());\n      \n      const codeLines = code.split(\"\\n\");\n      \n      String.prototype.replaceBetween = function(start, end, what) {\n        return this.substring(0, start) + what + this.substring(end);\n      };\n      codeLines[reference.line] = codeLines[reference.line].replaceBetween(reference.ch, reference.ch + identifier.node.name.length, newName);\n      \n      const newCode = codeLines.join(\"\\n\");\n      await lively.files.saveFile(reference.url, newCode);\n      await lively.reloadModule(reference.url)\n      await System.import(reference.url);\n    }\n  }\n\n  selectBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);\n    if (bindings) {\n      this.selectPaths(bindings);\n    }\n  }\n\n  async printAllBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    //const bindings = this.getBindings(selectedPath);\n    var identifier = this.getFirstSelectedIdentifier(selectedPath);\n\n    //find classes that contain the method\n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\n\n    this.openReferencesMenu(bindingItems, identifier.node.name);\n  }\n\n  async getPossibleBindingsAcrossFiles(identifier) {\n    let index = await FileIndex.current();\n    let ids = await index.db.files.filter(file => {\n      if (!file.unboundIdentifiers) return false;\n      return file.unboundIdentifiers.some(id => id.name == identifier.name);\n    }).toArray();\n    const bindingItems = [];\n\n    for (const id of ids) {\n      const code = await fetch(id.url).then(r => r.text());\n      const program = this.programPathFor(code);\n      for (const reference of this.getMemberBindings(identifier, true, program)) {\n        const line = reference.node.loc.start.line - 1;\n        const ch = reference.node.loc.start.column;\n        bindingItems.push({ id: id.url.substring(id.url.lastIndexOf(\"/\") + 1) + \": \" + line, url: id.url, line, ch });\n      }\n    }\n\n    return bindingItems;\n  }\n\n  async openReferencesMenu(ids, identifierName) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"References of \" + identifierName);\n    return comp.selectItems(ids);\n  }\n\n  async findImports() {\n    let functions, classes, identName;\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (identifier) {\n      identName = identifier.node.name;\n      functions = await this.getFunctionExportURLs(identName);\n      classes = await this.getCorrespondingClasses(identName);\n    }\n    return { identName, functions, classes };\n  }\n  /*MD ## Factoring Menu MD*/\n\n  /*MD ### Factoring Menu Helper Methods MD*/\n\n  // returns innermostDescribePath \n  isInDescribe(path) {\n    let possiblePath = this.isIn(\"CallExpression\", path, \"describe\");\n\n    while (possiblePath !== null) {\n      if (possiblePath.node && possiblePath.node.callee.name === \"describe\") {\n        break;\n      }\n      possiblePath = this.isIn(\"CallExpression\", possiblePath.parentPath, \"describe\");\n    }\n    return possiblePath;\n  }\n\n  isIn(type, path) {\n    while (path !== null) {\n      if (this.isDirectlyIn(type, path)) {\n        return path;\n      }\n      path = path.parentPath;\n    }\n    return null;\n  }\n\n  isDirectlyIn(type, path) {\n    if (type instanceof Array) {\n      return type.map(elem => this.isDirectlyIn(elem, path)).reduce((accu, elem) => accu || elem, false);\n    }\n    return path.node && path.node.type === type;\n  }\n\n  async openMenu() {\n\n    function fa(name, ...modifiers) {\n      return `<i class=\"fa fa-${name} ${modifiers.map(m => 'fa-' + m).join(' ')}\"></i>`;\n    }\n\n    const myself = this;\n    /*MD ### Generate Submenus MD*/\n\n    async function generateGenerationSubmenu() {\n\n      let submenu = [['Class', () => {\n        menu.remove();\n        myself.generateClass();\n      }, '→', fa('suitcase')]];\n\n      const selectedPath = myself.getInnermostPathContainingSelection(myself.programPath, myself.firstSelection);\n\n      //add testcase if in describe\n      if (myself.isInDescribe(selectedPath)) {\n        submenu.unshift(['Testcase', () => {\n          menu.remove();\n          myself.generateTestCase();\n        }, '→', fa('suitcase')]);\n      }\n\n      if (myself.isDirectlyIn([\"ClassBody\", \"ObjectExpression\"], selectedPath)) {\n        submenu.push(['Getter', () => {\n          menu.remove();\n          myself.generateGetter();\n        }, '→', fa('suitcase')], ['Setter', () => {\n          menu.remove();\n          myself.generateSetter();\n        }, '→', fa('suitcase')]);\n      }\n\n      return submenu;\n    }\n\n    async function generateImportSubmenu() {\n      let { identName, functions, classes } = await myself.findImports();\n      let submenu = [];\n      if (!identName || functions.length == 0 && classes.length == 0) {\n        submenu.push(['none', () => {\n          menu.remove();\n        }, '', '']);\n      } else {\n        functions.forEach(url => submenu.push([url.replace(lively4url, ''), () => {\n          menu.remove();\n          myself.addImport(url, identName, true);\n        }, '-', fa('share-square-o')]));\n        classes.forEach(cl => submenu.push([cl.name + \", \" + cl.url.replace(lively4url, ''), () => {\n          menu.remove();\n          myself.addImport(cl.url, cl.name, false);\n        }, '-', fa('share-square-o')]));\n      }\n      return submenu;\n    }\n\n    /*MD ### Generate Factoring Menu MD*/\n\n    const menuItems = [['selection to local variable', () => {\n      menu.remove();\n      this.extractExpressionIntoLocalVariable();\n    }, '→', fa('share-square-o', 'flip-horizontal')], ['wrap into active expression', () => {\n      menu.remove();\n      this.wrapExpressionIntoActiveExpression();\n    }, '→', fa('suitcase')], ['Rename', () => {\n      menu.remove();\n      this.rename();\n    }, 'Alt+R', fa('suitcase')], ['Extract Method', () => {\n      menu.remove();\n      this.extractMethod();\n    }, 'Alt+M', fa('suitcase'), () => {\n      const selection = this.selectMethodExtraction(this.programPath, true);\n      if (selection) {\n        this.changedSelectionInMenu = true;\n        this.selectPaths(selection.selectedPaths);\n      } else {\n        this.changedSelectionInMenu = false;\n      }\n    }, () => {\n      if (this.changedSelectionInMenu) {\n        this.editor.undoSelection();\n      }\n    }], ['Generate HTML Accessors', () => {\n      menu.remove();\n      this.generateHTMLAccessors();\n    }, 'Alt+H', fa('suitcase')], ['Print References', () => {\n      this.printAllBindings();\n      menu.remove();\n    }, 'Alt+I', fa('suitcase')], ['Generate', generateGenerationSubmenu()], ['Import', generateImportSubmenu()]];\n    var menuPosition = this.codeMirror.cursorCoords(false, \"window\");\n\n    const menu = await ContextMenu.openIn(document.body, { clientX: menuPosition.left, clientY: menuPosition.bottom }, undefined, document.body, menuItems);\n    menu.addEventListener(\"DOMNodeRemoved\", () => {\n      this.focusEditor();\n    });\n  }\n\n  /*MD ## Generations MD*/\n\n  /*MD ### Generate Testcase / Class / get / set / HTML accessorss MD*/\n\n  async openHTMLAccessorsMenu(ids, initialSelectionState) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"HTML Accessor Menu\");\n    return comp.selectItems(ids, initialSelectionState);\n  }\n\n  getExistingAccessors() {\n    let classMethodIdentifier;\n    this.programPath.traverse({\n      ExportDefaultDeclaration(path) {\n        if (path && path.node.declaration && path.node.declaration.type == \"ClassDeclaration\") {\n          classMethodIdentifier = path.node.declaration.body.body.map(elem => elem.key.name);\n          path.stop();\n        }\n      }\n    });\n    return classMethodIdentifier || [];\n  }\n\n  async generateHTMLAccessors() {\n    const ids = await this.compileListOfIDs();\n    if (ids.length == 0) {\n      return;\n    }\n\n    let existingMethods = this.getExistingAccessors();\n    let initialSelectionState = ids.map(elem => existingMethods.includes(this.generateMethodNameFromProperty(elem.id)));\n    const selectedItems = await this.openHTMLAccessorsMenu(ids, initialSelectionState);\n\n    if (selectedItems.length === 0) {\n      return;\n    }\n    lively.warn(`${selectedItems.length} Accessors generated`);\n\n    selectedItems.forEach(item => {\n      this.generateCodeFragment(item.id, name => this.compileHTMLGetter(name));\n      const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n      let line = selectedPath.parent.loc.end.line + 1;\n      this.editor.setSelection({ line, ch: 0 });\n    });\n  }\n\n  async compileListOfIDs() {\n    let editor = lively.allParents(this.livelyCodeMirror, undefined, true).find(ele => ele.tagName && ele.tagName === 'LIVELY-EDITOR');\n    let jsURI = encodeURI(editor.shadowRoot.querySelector(\"#filename\").value);\n    const htmlURI = jsURI::replaceFileEndingWith('html');\n    let html = await htmlURI.fetchText();\n\n    if (html === \"File not found!\\n\") {\n      lively.warn(\"There is no HTML associated with this file.\");\n      return [];\n    }\n\n    let tmp = <div></div>;\n    tmp.innerHTML = html;\n    let ids = tmp.childNodes[0].content.querySelectorAll(\"[id]\").map(ea => ea.id);\n\n    const htmlLines = html.split(\"\\n\");\n\n    const idsWithLocation = [];\n    for (const id of ids) {\n      for (const line of htmlLines) {\n        const indexOfId = line.indexOf(\"id=\\\"\" + id + \"\\\"\");\n        if (indexOfId !== -1) {\n          idsWithLocation.push({ id, url: htmlURI, line: htmlLines.indexOf(line), ch: indexOfId + 4 });\n          break;\n        }\n      }\n    }\n    return idsWithLocation;\n  }\n\n  generateTestCase() {\n    this.generateCodeFragment(\"ExplainWhatIsTested\", id => this.compileTestCase(id.identifier));\n  }\n\n  generateGetter() {\n    this.generateCodeFragment(\"NameThisGetter\", id => this.compileGetter(id.identifier));\n  }\n\n  generateSetter() {\n    this.generateCodeFragment(\"NameThisSetter\", id => this.compileSetter(id.identifier));\n  }\n\n  generateClass() {\n    this.generateCodeFragment(\"SetClassName\", id => this.compileClass(id.identifier));\n  }\n\n  async generateCodeFragment(identifier, replacementGenerator) {\n    const scrollInfo = this.scrollInfo;\n    const selection = this.firstSelection;\n\n    var identifierObject = { identifier };\n\n    var generatedCode;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let pathBefore = this.getPathBeforeCursor(programPath, selection.start);\n          let pathWithin = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n          // we're on top of the program\n          generatedCode = replacementGenerator(identifierObject);\n          if (pathBefore === undefined) {\n            pathWithin.unshiftContainer('body', generatedCode);\n          } else if (this.isDirectlyIn(pathWithin.type, pathBefore.parentPath)) {\n            pathBefore.insertAfter(generatedCode);\n          } else {\n            pathWithin.unshiftContainer('body', generatedCode);\n          }\n        }\n      }\n    })).code;\n\n    var pathToSelect;\n    this.programPath.traverse({\n      StringLiteral(path) {\n        if (!pathToSelect && path.node.value == identifierObject.identifier) {\n          pathToSelect = path;\n        }\n      },\n      Identifier(path) {\n        if (path.node.name == identifierObject.identifier) {\n          pathToSelect = path;\n          path.stop();\n        }\n      }\n    });\n    this.selectPaths([pathToSelect], true);\n\n    this.scrollTo(scrollInfo);\n    this.focusEditor();\n  }\n\n  compileTestCase(explanation) {\n    return template(\"it(EXP, () => {\\n\" + \"let put = 'code here';\" + \"})\")({\n      EXP: t.stringLiteral(explanation)\n    });\n  }\n\n  //TODO: nice identifier\n  compileGetter(propertyName) {\n    return t.classMethod(\"get\", t.identifier(propertyName), [], t.blockStatement([t.returnStatement(t.memberExpression(t.thisExpression(), t.identifier(\"internalPropertyName\")))]));\n  }\n\n  compileSetter(propertyName) {\n    return t.classMethod(\"set\", t.identifier(propertyName), [t.Identifier(\"newValue\")], t.blockStatement([t.expressionStatement(t.assignmentExpression(\"=\", t.memberExpression(t.thisExpression(), t.identifier(\"internalPropertyName\")), t.identifier(\"newValue\")))]));\n  }\n\n  compileClass(className) {\n    return t.classDeclaration(t.identifier(className), null, t.classBody([t.classMethod(\"constructor\", t.Identifier(\"constructor\"), [], t.blockStatement([]))]), []);\n  }\n\n  compileHTMLGetter(property) {\n    var propertyName = property.identifier;\n    var methodName = this.generateMethodNameFromProperty(propertyName);\n    property.identifier = methodName;\n    return t.classMethod(\"get\", t.identifier(methodName), [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(\"get\")), [t.stringLiteral(\"#\" + propertyName)]))]));\n  }\n\n  generateMethodNameFromProperty(name) {\n    return name.camelCase();\n  }\n\n  async getUserInput(description, defaultValue) {\n    let input = await lively.prompt(description, defaultValue);\n    return new Promise((resolve, reject) => {\n      if (input) {\n        resolve(input);\n      } else {\n        reject(\"No input given!\");\n      }\n    });\n  }\n\n  /*MD ### Generate Import MD*/\n\n  addImport(url, importName, isFunction) {\n    const selection = this.firstSelection;\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let existingImportStatement = this.nextPath(programPath, path => {\n            return t.isImportDeclaration(path) && path.node.source.value == url;\n          });\n          let selectedPath = this.getInnermostPathContainingSelection(programPath, selection);\n          if (!existingImportStatement) {\n            let importStatement = t.importDeclaration([t.importSpecifier(t.identifier(importName), t.identifier(importName))], t.stringLiteral(url));\n            programPath.node.body.unshift(importStatement);\n          } else if (!existingImportStatement.node.specifiers.some(spec => spec.imported.name == importName)) {\n            existingImportStatement.node.specifiers.push(t.identifier(importName));\n          }\n          if (!isFunction) {\n            selectedPath.replaceWith(t.memberExpression(t.identifier(importName), t.identifier(selectedPath.node.name)));\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Transformations MD*/\n\n  /*MD ### Extract Method MD*/\n  findParameters(identifiers, surroundingMethod, actualSelections) {\n    return identifiers.filter(identifier => {\n      return this.needsToBeParameter(identifier, surroundingMethod);\n    }).filter(identifier => {\n      const bindingPath = identifier.scope.getBinding(identifier.node.name).path;\n      return !this.isSelected(bindingPath, actualSelections);\n    }).map(identifier => {\n      return this.getBindingDeclarationIdentifierPath(identifier.scope.getBinding(identifier.node.name)).node;\n    });\n  }\n\n  shouldBeAsync(content) {\n    let hasAwait = false;\n    content.forEach(startPath => {\n      if (t.isAwaitExpression(startPath.node)) {\n        hasAwait = true;\n      } else {\n        startPath.traverse({\n          AwaitExpression(path) {\n            hasAwait = true;\n            path.stop();\n          }\n        });\n      }\n    });\n\n    return hasAwait;\n  }\n\n  couldBeStatic(content) {\n    let hasThis = false;\n    content.forEach(startPath => {\n      startPath.traverse({\n        ThisExpression(path) {\n          hasThis = true;\n          path.stop();\n        }\n      });\n    });\n\n    return !hasThis;\n  }\n\n  needsToBeParameter(identifier, surroundingMethod) {\n    return identifier.scope.hasBinding(identifier.node.name) && !surroundingMethod.parentPath.scope.hasBinding(identifier.node.name);\n  }\n\n  findReturnValues(identifiers, surroundingMethod, actualSelections) {\n    const bindings = [...new Set(identifiers.filter(identifier => {\n      return identifier.scope.hasBinding(identifier.node.name) && !surroundingMethod.parentPath.scope.hasBinding(identifier.node.name);\n    }).map(identifier => {\n      return identifier.scope.getBinding(identifier.node.name);\n    }))];\n\n    return bindings.filter(binding => {\n      const declarationInSelection = this.isSelected(binding.path, actualSelections);\n      const constantViolationInSelection = binding.constantViolations.some(constantViolation => this.isSelected(constantViolation, actualSelections));\n      const referenceOutsideSelection = binding.referencePaths.some(reference => !this.isSelected(reference, actualSelections));\n\n      return this.needsToBeReturned(declarationInSelection, constantViolationInSelection, referenceOutsideSelection);\n    }).map(binding => {\n      const constantViolationOutsideSelection = binding.constantViolations.some(constantViolation => !this.isSelected(constantViolation, actualSelections));\n      return { node: this.getBindingDeclarationIdentifierPath(binding).node, declaredInExtractedCode: this.isSelected(binding.path, actualSelections), constantViolationOutsideSelection };\n    });\n  }\n\n  needsToBeReturned(declarationInSelection, constantViolationInSelection, referenceOutsideSelection) {\n    return !declarationInSelection && constantViolationInSelection || (constantViolationInSelection || declarationInSelection) && referenceOutsideSelection;\n  }\n\n  createMethod(content, parameter, returnValues, scope, extractingExpression, shouldBeAsync, shouldBeStatic) {\n    if (extractingExpression && returnValues.length > 0) {\n      lively.warn(\"Unable to extract an expression, that assigns something to variables used outside the expression.\");\n    }\n    var returnStatement;\n    returnValues.forEach(returnValue => returnValue.returnIdentifier = returnValue.declaredInExtractedCode ? returnValue.node : t.identifier(returnValue.node.name + \"_return\"));\n    if (returnValues.length == 1) {\n      returnStatement = t.returnStatement(returnValues[0].node);\n    } else if (returnValues.length > 1) {\n      returnStatement = t.returnStatement(t.objectExpression(returnValues.map(i => t.objectProperty(i.returnIdentifier, i.node, false, true))));\n    }\n\n    var methodContent = content.map(p => {\n      //remove formatting for propper re-formatting\n      p.node.loc = null;\n      p.node.start = null;\n      p.node.end = null;\n      return p.node;\n    });\n    if (returnStatement) {\n      methodContent.push(returnStatement);\n    } else if (extractingExpression) {\n      methodContent = [t.returnStatement(content[0].node)];\n    }\n    const newMethod = t.classMethod(\"method\", t.identifier(\"HopefullyNobodyEverUsesThisMethodName\"), parameter, t.blockStatement(methodContent));\n    newMethod.async = shouldBeAsync;\n    newMethod.static = shouldBeStatic;\n    scope.insertAfter(newMethod);\n    for (let i = 0; i < content.length - 1; i++) {\n      content[i].remove();\n    }\n    var methodCall;\n    var callExpression = t.callExpression(t.identifier(\"this.HopefullyNobodyEverUsesThisMethodName\"), parameter);\n    if (shouldBeAsync) {\n      lively.warn(\"Extracting async method. This could change the control flow.\");\n      callExpression = t.awaitExpression(callExpression);\n    }\n    if (returnValues.length == 1) {\n      if (returnValues[0].declaredInExtractedCode) {\n        const variableType = returnValues[0].constantViolationOutsideSelection ? \"var\" : \"const\";\n        methodCall = [t.variableDeclaration(variableType, [t.variableDeclarator(returnValues[0].node, callExpression)])];\n      } else {\n        methodCall = [t.expressionStatement(t.assignmentExpression(\"=\", returnValues[0].node, callExpression))];\n      }\n    } else if (returnValues.length > 1) {\n      const objectPattern = t.objectPattern(returnValues.map(i => t.objectProperty(i.returnIdentifier, i.returnIdentifier, false, true)));\n      methodCall = [t.variableDeclaration(\"const\", [t.variableDeclarator(objectPattern, callExpression)])];\n      returnValues.forEach(returnStatement => {\n        if (returnStatement.node != returnStatement.returnIdentifier) {\n          methodCall.push(t.expressionStatement(t.assignmentExpression(\"=\", returnStatement.node, returnStatement.returnIdentifier)));\n        }\n      });\n    } else {\n      methodCall = [callExpression];\n    }\n    content[content.length - 1].replaceWithMultiple(methodCall);\n  }\n\n  async extractMethod() {\n    const scrollInfo = this.scrollInfo;\n    const transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const {\n            selectedPaths,\n            extractingExpression,\n            actualSelections\n          } = this.selectMethodExtraction(programPath);\n\n          const identifiers = selectedPaths.map(this.getAllIdentifiers).flat();\n          let surroundingMethod = selectedPaths[0].find(parent => {\n            return parent.node.type == \"ClassMethod\";\n          });\n          var shouldBeStatic = this.couldBeStatic(selectedPaths);\n          if (!surroundingMethod) {\n            surroundingMethod = selectedPaths[selectedPaths.length - 1];\n          } else {\n            shouldBeStatic = surroundingMethod.node.static;\n          }\n          const shouldBeAsync = this.shouldBeAsync(selectedPaths);\n          const parameters = this.findParameters(identifiers, surroundingMethod, actualSelections);\n          const returnValues = this.findReturnValues(identifiers, surroundingMethod, actualSelections);\n          this.createMethod(selectedPaths, [...new Set(parameters)], returnValues, surroundingMethod, extractingExpression, shouldBeAsync, shouldBeStatic);\n        }\n      }\n    }));\n    this.sourceCode = transformed.code;\n    this.scrollTo(scrollInfo);\n    const pathsToSelect = [];\n    this.programPath.traverse({\n      Identifier(path) {\n        if (path.node.name == \"HopefullyNobodyEverUsesThisMethodName\") {\n          pathsToSelect.push(path);\n        }\n      }\n    });\n    this.selectPaths(pathsToSelect);\n  }\n\n  /*MD ### Extract Variable MD*/\n\n  selectMethodExtraction(programPath, silent = false) {\n    var selectedPaths = this.getSelectedStatements(programPath);\n    var extractingExpression = false;\n\n    if (selectedPaths.length == 0) {\n      var expressions = this.getSelectedExpressions(programPath);\n      if (expressions.length > 1) {\n        if (!silent) lively.warn('You cannot extract multiple statements at once. Select statements or a single expression!');\n        return;\n      } else if (expressions.length == 0) {\n        if (!silent) lively.warn('Select statements or an expression to extract!');\n        return;\n      } else {\n        selectedPaths = expressions;\n        extractingExpression = true;\n      }\n    }\n\n    const actualSelections = selectedPaths.map(path => {\n      return range(path.node.loc);\n    });\n    return {\n      selectedPaths,\n      extractingExpression,\n      actualSelections\n    };\n  }\n\n  async extractExpressionIntoLocalVariable() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(({ types: t }) => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n\n              path.find(p => {\n                const parentPath = p.parentPath;\n                if (!parentPath) {\n                  return false;\n                }\n\n                function ensureBlock(body) {\n                  if (!body.node) return false;\n\n                  if (body.isBlockStatement()) {\n                    return false;\n                  }\n\n                  const statements = [];\n                  if (body.isStatement()) {\n                    statements.push(body.node);\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else if (body.parentPath.isArrowFunctionExpression() && body.isExpression()) {\n                    statements.push(t.returnStatement(body.node));\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else {\n                    throw new Error(\"I never thought this was even possible.\");\n                  }\n                }\n\n                const targetLocation = path.getPathLocation();\n                const blockLocation = p.getPathLocation();\n                if (p.parentKey === 'body' && (parentPath.isFor() || parentPath.isWhile())) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if (p.parentKey === 'body' && parentPath.isFunction()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0].argument' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if ((p.parentKey === 'consequent' || p.parentKey === 'alternate') && parentPath.isIfStatement()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n              });\n\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No Expression to extract found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          let value = '';\n          path.traverse({\n            Identifier(p) {\n              value += '-' + p.node.name;\n            }\n          });\n          if (value.length > 0) {\n            // #TODO: ensure unique identifier\n            value = value.camelCase();\n          } else {\n            value = path.scope.generateUidIdentifier('temp').name;\n          }\n          const identifier = t.Identifier(value);\n          const decl = template('const ID = INIT;')({\n            ID: identifier,\n            INIT: path.node\n          });\n\n          let referree = t.Identifier(value);\n\n          path.replaceWith(referree);\n          const insertedDeclaration = path.getStatementParent().insertBefore(decl)[0];\n          const insertedDeclarationIdentifier = insertedDeclaration.get('declarations')[0].get('id');\n\n          pathLocationsToSelect.push(insertedDeclarationIdentifier.getPathLocation());\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.focusEditor();\n    this.scrollTo(scrollInfo);\n  }\n\n  async wrapExpressionIntoActiveExpression() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No `Expression` to wrap found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          const ae = template('aexpr(() => EXPR)')({\n            EXPR: path.node\n          }).expression;\n\n          path.replaceWith(ae);\n\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.focusEditor();\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Accessors MD*/\n\n  get sourceCode() {\n    return this.livelyCodeMirror.value;\n  }\n  set sourceCode(text) {\n    this.livelyCodeMirror.value = text;\n    this.codeChanged();\n    return this.livelyCodeMirror.value;\n  }\n\n  focusEditor() {\n    this.livelyCodeMirror.focus();\n  }\n\n  get scrollInfo() {\n    return this.codeMirror.getScrollInfo();\n  }\n  scrollTo(scrollInfo) {\n    this.codeMirror.scrollIntoView({\n      left: scrollInfo.left,\n      top: scrollInfo.top,\n      right: scrollInfo.left + scrollInfo.width,\n      bottom: scrollInfo.top + scrollInfo.height\n    }, 120);\n  }\n\n  /*MD ## Utilities MD*/\n\n  isSelected(path, selections = null) {\n    if (!selections) {\n      selections = this.selectionRanges;\n    }\n    const pathRange = range(path.node.loc);\n    for (const selection of selections) {\n      if (selection.containsRange(pathRange)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  isPathExactlySelected(path, selection) {\n    return selection.isEqual(range(path.node.loc));\n  }\n\n  pathByLocationFromProgram(programPath, location) {\n    let path = programPath;\n    const reg = /(\\.[A-Za-z0-9]+|(\\[[0-9]+\\]))/ig;\n    let result;\n    while ((result = reg.exec(location)) !== null) {\n      let part = result[0];\n      if (part.startsWith('.')) {\n        part = part.replace('.', '');\n        path = path.get(part);\n      } else {\n        part = part.replace(/\\[|\\]/ig, '');\n        part = parseInt(part);\n        path = path[part];\n      }\n    }\n\n    return path;\n  }\n\n  pathLocationsToPathes(pathLocations) {\n    const paths = [];\n\n    this.sourceCode.traverseAsAST({\n      Program: path => {\n        pathLocations.forEach(location => {\n          paths.push(this.pathByLocationFromProgram(path, location));\n        });\n      }\n    });\n\n    return paths;\n  }\n\n  async getCorrespondingClasses(methodName) {\n    let index = await FileIndex.current();\n\n    //find classes that contain the method\n    let possibleClasses = await index.db.classes.filter(cl => {\n      return cl.methods.some(me => me.name == methodName);\n    }).toArray();\n\n    //find files that export things with the urls from the found classes\n    let possibleExports = await index.db.exports.where('url').anyOf(possibleClasses.map(cl => cl.url)).toArray();\n\n    //reduce the found classes with the found possible exports\n    let locations = possibleClasses.filter(cl => {\n      return possibleExports.some(e => e.url == cl.url && e.classes.some(eCl => eCl == cl.name));\n    });\n    return locations.filter(ea => ea.url.match(lively4url)); //filter local files\n  }\n\n  async getFunctionExportURLs(methodName) {\n    let index = await FileIndex.current();\n    let locations = await index.db.exports.filter(exp => {\n      return exp.functions.some(me => me == methodName);\n    }).toArray();\n    return locations.map(loc => loc.url).filter(url => url.match(lively4url));\n  }\n\n  /*MD ## Color Picker MD*/\n\n  updateColorPicker() {\n    const pPath = this.programPath;\n    if (!pPath) {\n      return;\n    }\n    const old = this.editor.getAllMarks();\n    old.forEach(marker => {\n      if (marker.type === \"bookmark\") {\n        marker.clear();\n      }\n    });\n    const colorLiterals = this.getColorLiterals(pPath);\n    colorLiterals.forEach(path => {\n      const location = { line: path.node.loc.end.line - 1, ch: path.node.loc.end.column };\n      var picker = document.createElement(\"input\");\n      picker.type = \"color\";\n      picker.value = path.node.value;\n      picker.height = \"15\";\n      picker.width = \"15\";\n      const bookmark = this.editor.setBookmark(location, picker);\n      picker.addEventListener('change', event => {\n        const currentLocation = bookmark.find();\n        this.updateColor(currentLocation, event.target.value);\n      });\n    });\n  }\n\n  updateColor(currentLocation, color) {\n    var location = { anchor: currentLocation, head: currentLocation };\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.getInnermostPathContainingSelection(programPath, range(location)); //this.getPathBeforeCursor(programPath, currentLocation);\n          if (t.isStringLiteral(path.node)) {\n            path.node.value = color;\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n    this.updateColorPicker();\n  }\n\n}"]}