{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-augment/src/components/widgets/lively-code-mirror-ast-capabilities.js"],"names":["loc","range","fileEnding","replaceFileEndingWith","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","getBindings","identifierPaths","Set","referencePaths","constantViolations","cv","includes","getClassBindings","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","selectBindings","printAllBindings","current","ids","db","files","file","some","toArray","bindingItems","fetch","r","text","program","reference","line","column","substring","lastIndexOf","openReferencesMenu","identifierName","comp","openComponentInWindow","focus","setTitle","selectItems","findImports","functions","classes","isInDescribe","possiblePath","isIn","callee","isDirectlyIn","Array","elem","reduce","accu","openMenu","fa","modifiers","m","join","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","split","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","camelCase","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 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  getBindings(startPath) {\n    var identifier = this.getFirstSelectedIdentifier(startPath);\n    if (!identifier) return;\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\n    return this.getClassBindings(identifier);\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\n      .map(binding => binding.node.name)\n      .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.getBindings(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  selectBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindings(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    let index = await FileIndex.current();\n\n    //find classes that contain the method\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    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    this.openReferencesMenu(bindingItems, identifier.node.name);\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.selectBindings();\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}"]}