{"version":3,"sources":["https://lively-kernel.org/lively4/composed-offset/src/components/widgets/ast-capabilities.js"],"names":["loc","range","FileIndex","MousePosition","diff","babelDefault","indentFromTo","comparePos","lineLength","copyCursor","DMP_DELETION","DMP_EQUALITY","DMP_INSERTION","babel","t","types","template","cur","CodeMirror","Pos","line","ch","cm","lineNum","getLine","length","a","b","ASTCapabilities","constructor","codeProvider","codeChanged","selectionRanges","selections","firstSelection","map","_getFirstSelectionOrCursorPosition","anchor","cursor","head","newlineAndIndent","after","codeMirror","insertAt","getCursor","firstLine","replaceRange","setCursor","newlineFn","commands","newlineAndIndentContinueComment","livelyNotify","livelyCodeMirror","lcm","before","selectionTexts","getSelections","replaceSelections","listSelections","forEach","left","right","isBefore","setSelections","undefined","scroll","lively4url","l4url","l4urlplus","simples","Set","i","add","has","replaceParentWithSelection","scrollInfo","lively","noti","exitedEarly","pathLocationToSelect","transformed","sourceCode","transformAsAST","visitor","Program","programPath","selectedPath","getInnermostPathContainingSelection","parentPath","warn","getPathLocation","replaceWith","node","code","pathsToSelect","pathLocationsToPathes","selectPaths","scrollTo","selectPrevious","searchString","startPos","headIndex","indexFromPos","str","getValue","compareString","startsWith","posFromIndex","setSelection","generateIf","type","somethingSelected","CONDITION_IDENTIFIER","lineContent","test","replaceSelection","Infinity","pathLocationsToSelect","selectMethodExtraction","silent","selectedPaths","getSelectedStatements","extractingExpression","expressions","getSelectedExpressions","actualSelections","path","notify","push","statement","getStatementParent","ifStatement","identifier","blockStatement","swapConditional","find","p","isIfStatement","then","consequent","alternate","body","negateExpression","negatableBinaryOperators","pathToNegate","parentKey","isBinaryExpression","operator","isVariableDeclarator","isUnaryExpression","get","negatedOperator","unaryExpression","insertMarkdownComment","around","fill","braveNewWorld","insertLastDefinedVariable","n","firstRange","first","s","scope","identifiers","Object","values","bindings","binding","parent","cursorIndex","positions","start","end","name","asCM","filter","sortBy","position","getItem","insertArrowFunction","numArgs","isPlural","endsWith","makeSingular","matches","matchAll","substring","last","index","slice","lowerCase","getStart","selection","getEnd","arg1s","selectionRange","scopePath","traverse","Identifier","e","arg1identifier","reverse","getExpression","selectionText","flatMap","argumentStart","expressionEnd","argument","expressionText","expression","highlightChanges","from","document","querySelector","editor","to","targetLCM","targetCM","oldText","newText","value","dmp","diff_match_patch","d","diff_main","firstChangeStep","onlySpaces","trim","changeType","text","highlightChange","psych","pt","elementsFromPoint","webComponent","tagName","includes","coordsChar","x","top","y","w","findWordAt","underlineText","replaceSelectionWith","getRange","that","findMatchingBracket","pos","strict","config","showElement","textContent","drawLineFor","drawLineFragment","posA","posB","showPath","bottom","anchorLeft","anchorBottom","charCoords","anchorRight","anchorBottomRight","startCh","currentCh","lastPos","assign","currentPos","anchorLine","headLine","psychEach","hoveredPosition","anchorIndex","letter","c","small","big","foundBig","charToAdd","foundSmall","psychTo","char","inclusive","findSmartAroundSelection","asFromTo","fromIndex","toIndex","match","isLeft","isRight","getLeft","getRight","psychUtils","startIndex","endIndex","stack","onLeftSide","onRightSide","pushOntoStack","m","pop","error","psychInSmart","getLeftRightCharacters","Error","scanLeftRight","psychIn","stackLeft","stackRight","lrPairs","concat","some","pair","showPoint","underlinePath","color","slurpOrBarf","slurp","barf","forward","getScrollInfo","setScrollInfo","scrollIntoView","width","height","res","innerBlock","isBlock","outerStatement","getNextSibling","getPrevSibling","pathToSlurp","pushContainer","remove","unshiftContainer","expressionStatement","pathToBarf","insertAfter","insertBefore","myProgramPath","parsingFailed","programPathFor","traverseAsAST","err","rootNode","finishedEnrichment","memberAssignments","Map","aexprs","canParse","nextPath","startingPath","isValid","pathToShow","enter","stop","getLastPath","nextPathCallback","getFirstChildOrSelf","child","getPathBeforeCursor","selectionStart","foundPath","exit","pathLocation","pathEnd","nextPathContainingCursor","newStartingPath","containsRange","prevPath","getSelectedPaths","pathContainingWholeSelection","isPathExactlySelected","containsPartsOfRange","skip","flat","getOutermostPathContainingSelectionWithMinimalSelectionRange","isStatement","isBlockStatement","Statement","isExpression","isIdentifier","Expression","currentPath","findParent","isEqual","forwardList","linearizedPathList","backwardList","selectNextASTNodeWith","condition","reversed","pathList","maxPaths","getNextASTNodeInListWith","getFirstSelectedIdentifier","startPath","getFirstSelectedIdentifierWithName","getAllIdentifiers","getDeclaration","hasBinding","getBinding","getBindingDeclarationIdentifierPath","getBindingsInFile","astBindings","getASTBinding","getClassBindings","identifierPaths","referencePaths","constantViolations","cv","isMemberExpression","isThisExpression","object","classPath","getClassPath","methodPath","getMethodPath","getClassMethodBindings","getMemberBindings","isClassMethod","classMethod","methodIdentifier","getUnbound","members","getAllUnboundIdentifierNames","unboundIdentifiers","self","indexOf","conditionFunc","currentPathInList","pathInList","currentIndex","selectNodes","nodes","selectStringContentsOnly","ranges","selectedRange","_cmCharacter","paths","ClassMethod","key","FunctionDeclaration","id","ClassDeclaration","getColorLiterals","pPath","colorPaths","colorRegex","StringLiteral","expandSelectionOLD","strictlyContainsRange","expandSelection","bar","foo","resultSelection","fullySelected","isTemplateLiteral","r","isStringLiteral","isTemplateElement","reduceSelection","selectNextASTChild","currentNode","nextNode","isLiteral","isSuper","isDebuggerStatement","selectNextASTNodeLikeThis","selectNextReference","sortedBindings","sort","selectDeclaration","identName","declaration","isImportSpecifier","classUrls","getCorrespondingClasses","arr","cl","url","functionUrls","getFunctionExportURLs","urls","openBrowser","container","asyncGet","livelyEditor","newCodeMirror","awaitEditor","astCapabilities","ac","rename","bindingItems","getPossibleBindingsAcrossFiles","comp","openComponentInWindow","focus","setAdditionalInput","setTitle","references","selectItems","newName","getAdditionalInput","camelCase","reference","fetch","codeLines","split","String","prototype","replaceBetween","what","newCode","join","files","saveFile","reloadModule","System","import","selectBindings","printAllBindings","openReferencesMenu","current","ids","db","file","toArray","program","column","lastIndexOf","identifierName","findImports","functions","classes","isInDescribe","possiblePath","isIn","callee","isDirectlyIn","Array","elem","reduce","accu","updateColor","currentLocation","location","openHTMLAccessorsMenu","initialSelectionState","getExistingAccessors","classMethodIdentifier","ExportDefaultDeclaration","generateHTMLAccessors","compileListOfIDs","existingMethods","generateMethodNameFromProperty","selectedItems","item","generateCodeFragment","compileHTMLGetter","htmlURI","html","fetchText","tmp","innerHTML","childNodes","content","querySelectorAll","ea","htmlLines","idsWithLocation","indexOfId","generateTestCase","compileTestCase","generateGetter","compileGetter","generateSetter","compileSetter","generateClass","compileClass","replacementGenerator","identifierObject","generatedCode","pathBefore","pathWithin","pathToSelect","explanation","EXP","stringLiteral","propertyName","returnStatement","memberExpression","thisExpression","assignmentExpression","className","classDeclaration","classBody","property","methodName","callExpression","addImport","importName","isFunction","existingImportStatement","isImportDeclaration","source","importStatement","importDeclaration","importSpecifier","unshift","specifiers","spec","imported","findParameters","surroundingMethod","needsToBeParameter","bindingPath","isSelected","shouldBeAsync","hasAwait","isAwaitExpression","AwaitExpression","couldBeStatic","hasThis","ThisExpression","findReturnValues","declarationInSelection","constantViolationInSelection","constantViolation","referenceOutsideSelection","needsToBeReturned","constantViolationOutsideSelection","declaredInExtractedCode","createMethod","parameter","returnValues","shouldBeStatic","returnValue","returnIdentifier","objectExpression","objectProperty","methodContent","newMethod","async","static","methodCall","awaitExpression","variableType","variableDeclaration","variableDeclarator","objectPattern","replaceWithMultiple","extractMethod","extraction","parameters","extractExpressionIntoLocalVariable","done","pathLocationToBeExtracted","isSelectedPath","ensureBlock","statements","blockNode","isArrowFunctionExpression","targetLocation","blockLocation","isFor","isWhile","becameABlock","replace","resultExtracted","pathByLocationFromProgram","generateUidIdentifier","decl","ID","INIT","referree","insertedDeclaration","insertedDeclarationIdentifier","inlineLocalVariable","kind","declarationIdentifierPath","isVariableDeclaration","initPath","o","wrapExpressionIntoActiveExpression","ae","EXPR","pathRange","reg","result","exec","part","parseInt","pathLocations","possibleClasses","methods","me","possibleExports","exports","where","anyOf","locations","eCl","exp","defineProperty","configurable","enumerable"],"mappings":"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","file":"ast-capabilities.js","sourcesContent":["import { loc, range } from 'utils';\n\nimport FileIndex from \"src/client/fileindex.js\";\nimport MousePosition from 'src/client/mouse-position.js';\n\nimport diff from 'src/external/diff-match-patch.js';\nconst DMP_DELETION = -1,\n      DMP_EQUALITY = 0,\n      DMP_INSERTION = 1;\n\nimport babelDefault from 'systemjs-babel-build';\nconst babel = babelDefault.babel;\n\nconst t = babel.types;\nconst template = babel.template;\n\nimport { indentFromTo } from './code-mirror-utils.js';\n\nfunction copyCursor(cur) {\n  return CodeMirror.Pos(cur.line, cur.ch);\n}\nfunction lineLength(cm, lineNum) {\n  return cm.getLine(lineNum).length;\n}\nfunction comparePos(a, b) {\n  return a.line - b.line || a.ch - b.ch;\n}\n\nexport default class ASTCapabilities {\n\n  constructor(codeProvider) {\n    this.codeProvider = codeProvider;\n    this.codeChanged();\n  }\n\n  get selectionRanges() {\n    if (this.codeProvider.selections.length == 0) {\n      return this.firstSelection;\n    }\n    return this.codeProvider.selections.map(range);\n  }\n\n  get firstSelection() {\n    return range(this._getFirstSelectionOrCursorPosition());\n  }\n\n  _getFirstSelectionOrCursorPosition() {\n    if (this.codeProvider.selections.length == 0) {\n      return { anchor: this.codeProvider.cursor, head: this.codeProvider.cursor };\n    }\n    return this.codeProvider.selections[0];\n  }\n\n  newlineAndIndent(after) {\n    const cm = this.codeProvider.codeMirror;\n\n    const insertAt = copyCursor(cm.getCursor());\n    if (insertAt.line === cm.firstLine() && !after) {\n      // Special case for inserting newline before start of document.\n      cm.replaceRange('\\n', CodeMirror.Pos(cm.firstLine(), 0));\n      cm.setCursor(cm.firstLine(), 0);\n    } else {\n      insertAt.line = after ? insertAt.line : insertAt.line - 1;\n      insertAt.ch = lineLength(cm, insertAt.line);\n      cm.setCursor(insertAt);\n      var newlineFn = CodeMirror.commands.newlineAndIndentContinueComment || CodeMirror.commands.newlineAndIndent;\n      newlineFn(cm);\n    }\n  }\n\n  livelyNotify() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    const before = 'lively.notify(';\n    const after = ')';\n\n    const selectionTexts = cm.getSelections();\n    cm.replaceSelections(selectionTexts.map(t => before + t + after), \"around\"\n    // selections.forEach()\n    );const selections = cm.listSelections();\n    selections.forEach(({ anchor, head }) => {\n      const [left, right] = loc(anchor).isBefore(head) ? [anchor, head] : [head, anchor];\n      left.ch += before.length;\n      right.ch -= after.length;\n    });\n    cm.setSelections(selections, undefined, {\n      scroll: false\n    });\n  }\n\n  lively4url() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    const l4url = 'lively4url';\n    const l4urlplus = l4url + ' + ';\n\n    const selectionTexts = cm.getSelections();\n    const simples = new Set();\n    cm.replaceSelections(selectionTexts.map((t, i) => {\n      if (t.length > 0) {\n        return l4urlplus + t;\n      } else {\n        simples.add(i);\n        return l4url;\n      };\n    }), \"around\");\n    const selections = cm.listSelections();\n    selections.forEach(({ anchor, head }, i) => {\n      const [left, right] = loc(anchor).isBefore(head) ? [anchor, head] : [head, anchor];\n      if (simples.has(i)) {\n        left.ch += l4url.length;\n      } else {\n        // select `lively4url + <prior>`\n      }\n    });\n    cm.setSelections(selections, undefined, {\n      scroll: false\n    });\n  }\n  // replace parent with me\n  // #TODO: also for multiselections\n  replaceParentWithSelection() {\n    const scrollInfo = this.scrollInfo;\n    lively.noti;\n    let exitedEarly = false;\n\n    let pathLocationToSelect;\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const parentPath = selectedPath.parentPath;\n\n          // #TODO: which cases do we not want to support?\n          if (false) {\n            lively.warn('special case not supported');\n            exitedEarly = true;\n            return;\n          }\n\n          //           // #TODO: smooth some rough edges\n\n          //           const variableDeclarator = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclarator());\n          //           const variableDeclaration = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclaration());\n          //           const initPath = variableDeclarator.get('init');\n\n          // default case\n          pathLocationToSelect = parentPath.getPathLocation();\n          parentPath.replaceWith(selectedPath.node);\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes([pathLocationToSelect]);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  // search and select backwards from cursor\n  selectPrevious(cm, searchString, startPos) {\n    let headIndex = cm.indexFromPos({ line: startPos.line, ch: startPos.ch });\n\n    const str = cm.getValue();\n    let compareString = '';\n    while (headIndex >= 0) {\n      compareString = str[headIndex] + compareString;\n\n      if (compareString.startsWith(searchString)) {\n        break;\n      } else {\n        headIndex--;\n      }\n    }\n    const anchor = cm.posFromIndex(headIndex);\n    const head = cm.posFromIndex(headIndex + searchString.length);\n\n    cm.setSelection(anchor, head);\n  }\n\n  generateIf(type) {\n    const cm = this.codeProvider.codeMirror;\n\n    const selections = cm.getSelections();\n    if (selections.length === 1 && !cm.somethingSelected()) {\n      const CONDITION_IDENTIFIER = 'condition';\n      const { line } = cm.getCursor();\n      const lineContent = cm.getLine(line);\n\n      if (/^\\s*$/.test(lineContent)) {\n        cm.replaceSelection(`if (${CONDITION_IDENTIFIER}) {\n  \n}`, 'start');\n        cm::indentFromTo(line, line + 2);\n        let { ch } = cm.getCursor();\n\n        // select condition\n        ch += 4;\n        cm.setSelection({ line, ch: ch + CONDITION_IDENTIFIER.length }, { line, ch });\n      } else {\n        cm.replaceRange(`if (${CONDITION_IDENTIFIER}) {\n${lineContent}\n}`, { line, ch: 0 }, { line, ch: Infinity }, \"+input\");\n        cm::indentFromTo(line, line + 2);\n        this.selectPrevious(cm, CONDITION_IDENTIFIER, { line, ch: Infinity });\n      }\n      return;\n    }\n\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          function 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('2222You cannot extract multiple statements at once. Select statements or a single expression!2');\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          var selectedPaths = this.getSelectedStatements(programPath);\n          lively.notify(selectedPaths.length);\n          if (selectedPaths.length == 0) {\n            lively.notify('no path');\n            return;\n          }\n          pathLocationsToSelect.push(...selectedPaths.map(statement => statement.getPathLocation()));\n          return;\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const statement = selectedPath.getStatementParent();\n          pathLocationsToSelect.push(statement.getPathLocation() + '.test');\n\n          statement.replaceWith(t.ifStatement(t.identifier('condition'), t.blockStatement([statement.node])));\n\n          return;\n          {\n            const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n            const statement = selectedPath.getStatementParent();\n            pathLocationsToSelect.push(statement.getPathLocation() + '.test');\n\n            statement.replaceWith(t.ifStatement(t.identifier('condition'), t.blockStatement([statement.node])));\n          }\n          if (type === 'condition') {\n            programPath;\n          } else if (type === 'then') {\n            programPath;\n          } else if (type === 'else') {\n            programPath;\n          }\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  // # Swap if and else blocks of a conditional\n  swapConditional() {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const ifStatement = selectedPath.find(p => p.isIfStatement());\n          if (!ifStatement) {\n            lively.warn('not within an if statement');\n            exitedEarly = true;\n            return;\n          }\n\n          pathLocationsToSelect.push(ifStatement.getPathLocation());\n\n          const then = ifStatement.node.consequent;\n          ifStatement.node.consequent = ifStatement.node.alternate || t.blockStatement([]);\n          if (then.type === 'BlockStatement' && then.body.length === 0) {\n            ifStatement.node.alternate = null;\n          } else {\n            ifStatement.node.alternate = then;\n          }\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  // # Swap if and else blocks of a conditional\n  negateExpression() {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const negatableBinaryOperators = {\n            \"==\": \"!=\",\n            \"!=\": \"==\",\n            \"===\": \"!==\",\n            \"!==\": \"===\",\n            \"<\": \">=\",\n            \"<=\": \">\",\n            \">\": \"<=\",\n            \">=\": \"<\"\n          };\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          let pathToNegate = selectedPath.find(p => {\n            const parentPath = p.parentPath;\n\n            if (!parentPath) {\n              return false;\n            }\n\n            if (parentPath.isIfStatement() && p.parentKey === 'test') {\n              return true;\n            }\n\n            if (p.isBinaryExpression() && negatableBinaryOperators[p.node.operator]) {\n              return true;\n            }\n\n            return false;\n          });\n\n          pathToNegate = pathToNegate || selectedPath.find(p => {\n            const parentPath = p.parentPath;\n            return parentPath && parentPath.isVariableDeclarator() && p.parentKey === 'init';\n          });\n\n          if (!pathToNegate) {\n            lively.warn('not within a negatable node');\n            exitedEarly = true;\n            return;\n          }\n\n          pathLocationsToSelect.push(pathToNegate.getPathLocation());\n\n          if (pathToNegate.isUnaryExpression() && pathToNegate.node.operator === '!') {\n            pathToNegate.replaceWith(pathToNegate.get('argument').node);\n          } else {\n            const negatedOperator = negatableBinaryOperators[pathToNegate.node.operator];\n            if (pathToNegate.isBinaryExpression() && negatedOperator) {\n              pathToNegate.node.operator = negatedOperator;\n            } else {\n              pathToNegate.replaceWith(t.unaryExpression(\"!\", pathToNegate.node));\n            }\n          }\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  insertMarkdownComment() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    const before = '/*M' + 'D ## ';\n    const around = 'your text';\n    const after = ' MD*/';\n    const l4url = 'lively4url';\n    const l4urlplus = l4url + ' + ';\n\n    const selections = cm.getSelections();\n    cm.replaceSelections(selections.fill(before));\n    cm.replaceSelections(selections.fill(after), \"start\");\n    cm.replaceSelections(selections.fill(around), \"around\");\n  }\n  braveNewWorld() {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n\n    this.insertLastDefinedVariable();\n  }\n\n  // #TODO: multi-selection\n  insertLastDefinedVariable(n = 1) {\n    const { livelyCodeMirror: lcm, codeMirror: cm } = this.codeProvider;\n    const firstRange = range(cm.listSelections().first);\n    const path = this.getInnermostPathContainingSelection(this.programPath, firstRange);\n\n    var s = path.scope;\n    const identifiers = [];\n    do {\n      Object.values(s.bindings).forEach(binding => identifiers.push(binding.identifier));\n    } while (s = s.parent);\n\n    const cursorIndex = cm.indexFromPos(cm.getCursor());\n    let positions = identifiers.map(identifier => {\n      const { start, end } = range(identifier.loc);\n\n      return {\n        name: identifier.name,\n        start: cm.indexFromPos(start.asCM()),\n        end: cm.indexFromPos(end.asCM())\n      };\n    });\n    positions = positions.filter(({ start }) => start < cursorIndex).sortBy(({ start }) => start);\n\n    const position = positions.getItem(-n);\n    const anchor = cm.posFromIndex(position.start);\n    const head = cm.posFromIndex(position.end);\n    // cm.setSelection(anchor, head);\n\n    cm.replaceSelection(position.name);\n  }\n\n  insertArrowFunction(numArgs = 1) {\n    function isPlural(name) {\n      return name.endsWith('s') && name.length > 1;\n    }\n    function makeSingular(name) {\n      const matches = [...name.matchAll(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/gm)]\n      if (matches.length === 0) {\n        return name\n      }\n      return name.substring(matches.last.index).slice(0, -1).lowerCase();\n    }\n    function getStart(selection) {\n      return comparePos(selection.anchor, selection.head) < 1 ? selection.anchor : selection.head;\n    }\n    function getEnd(selection) {\n      return comparePos(selection.anchor, selection.head) < 1 ? selection.head : selection.anchor;\n    }\n\n    const { codeMirror: cm } = this.codeProvider;\n    \n    const selections = cm.listSelections();\n    const selectionTexts = cm.getSelections();\n    const arg1s = selections.map((selection, i) => {\n      const selectionRange = range(selection);\n      const cursorIndex = cm.indexFromPos(getStart(selection));\n      const identifiers = [];\n      try {\n        const path = this.getInnermostPathContainingSelection(this.programPath, selectionRange);\n\n        const scopePath = path.scope.path;\n        scopePath.traverse({\n          Identifier(path) {\n            identifiers.push(path.node);\n          }\n        });\n      } catch(e) {}\n\n      const arg1identifier = identifiers.reverse().find(identifier => {\n        const { start, end } = range(identifier.loc);\n        return isPlural(identifier.name) && cm.indexFromPos(start.asCM()) < cursorIndex;\n      });\n      return arg1identifier ? makeSingular(arg1identifier.name) : 'ea';\n    });\n\n    function getExpression(i) {\n      const selectionText = selectionTexts[i];\n      return selectionText === '' ? arg1s[i] : selectionText;\n    }\n    cm.replaceSelections(selectionTexts.map((selection, i) => {\n      return `${arg1s[i]} => ${getExpression(i)}`;\n    }), 'around');\n\n    cm.setSelections(cm.listSelections().flatMap((selection, i) => {\n      const argumentStart = getStart(selection);\n      const expressionEnd = getEnd(selection);\n      const argument = {\n        anchor: argumentStart,\n        head: cm.posFromIndex(cm.indexFromPos(argumentStart) + arg1s[i].length)\n      };\n      const expressionText = getExpression(i);\n      const expression = {\n        anchor: cm.posFromIndex(cm.indexFromPos(expressionEnd) - expressionText.length),\n        head: expressionEnd\n      };\n\n      return [argument, expression];\n    }), 1);\n  }\n\n  highlightChanges() {\n    const from = document.querySelector('#from').editor;\n    const to = document.querySelector('#to').editor;\n    const targetLCM = document.querySelector('#target');\n    const targetCM = targetLCM.editor;\n    const oldText = from.getValue();\n    const newText = to.getValue();\n\n    targetLCM.value = oldText;\n\n    var dmp = new diff.diff_match_patch();\n    var d = dmp.diff_main(oldText, newText);\n    // d.inspect()\n    var index = 0;\n    let firstChangeStep = true;\n    // prune diffs\n    const onlySpaces = str => str.trim().length === 0;\n    // d = d.filter(([changeType, text]) => changeType === 0 || !onlySpaces(text));\n    // d.inspect()\n    for (let [changeType, text] of d) {\n      index = this.highlightChange(changeType, targetCM, text, index);\n      firstChangeStep = false;\n    }\n  }\n\n  highlightChange(changeType, cm, text, index) {\n    switch (changeType) {\n      case DMP_EQUALITY:\n        index += text.length;\n        break;\n      case DMP_INSERTION:\n        cm.replaceRange(text, cm.posFromIndex(index), cm.posFromIndex(index), 'insertion');\n        index += text.length;\n        break;\n      case DMP_DELETION:\n        cm.replaceRange('', cm.posFromIndex(index), cm.posFromIndex(index + text.length), 'deletion');\n        break;\n    }\n\n    return index;\n  }\n\n  /*MD ## Psych (paste from mouse) MD*/\n  psych() {\n    const pt = MousePosition.pt;\n\n    const elementsFromPoint = MousePosition.elementsFromPoint(pt);\n    if (elementsFromPoint.length === 0) {\n      lively.warn('no element under cursor found');\n      return;\n    }\n\n    const webComponent = elementsFromPoint.find(e => e.tagName.includes('-'));\n\n    if (webComponent && webComponent.tagName === 'LIVELY-CODE-MIRROR') {\n      const cm = webComponent.editor;\n      const { line, ch } = cm.coordsChar({ left: pt.x, top: pt.y }, \"window\");\n      const w = cm.findWordAt({ line, ch });\n      const { anchor, head } = w;\n      this.underlineText(cm, anchor, head);\n      this.replaceSelectionWith(cm.getRange(anchor, head));\n      return;\n      that.editor.findMatchingBracket(pos, strict, config);\n    }\n\n    lively.showElement(elementsFromPoint.first);\n    this.replaceSelectionWith(elementsFromPoint.first.textContent);\n  }\n\n  underlineText(cm, anchor, head) {\n\n    function drawLineFor(from, to) {\n      if (from.ch === Infinity) {\n        from.ch = cm.getLine(from.line).length;\n      }\n      if (to.ch === Infinity) {\n        to.ch = cm.getLine(to.line).length;\n      }\n\n      function drawLineFragment(posA, posB) {\n        lively.showPath([{ x: posA.left, y: posA.bottom }, { x: posB.left, y: posB.bottom }], 'black', false);\n      }\n      {\n        // short line :)\n        const { left: anchorLeft, bottom: anchorBottom } = cm.charCoords(from, 'window');\n        const { left: anchorRight, bottom: anchorBottomRight } = cm.charCoords(to, 'window');\n\n        if (anchorBottom === anchorBottomRight) {\n          lively.showPath([{ x: anchorLeft, y: anchorBottom }, { x: anchorRight, y: anchorBottomRight }], 'black', false);\n          return;\n        }\n      }\n\n      // long line support\n      let line = from.line;\n      let startCh = from.ch;\n      let currentCh = startCh;\n      let startPos = cm.charCoords({ line, ch: startCh }, 'window');\n      let lastPos = Object.assign({}, startPos);\n      while (currentCh <= to.ch) {\n        let currentPos = cm.charCoords({ line, ch: currentCh }, 'window');\n        if (currentPos.bottom > startPos.bottom) {\n          drawLineFragment(startPos, lastPos);\n          startPos = currentPos;\n        }\n        lastPos = currentPos;\n        currentCh++;\n      }\n      drawLineFragment(startPos, lastPos);\n    }\n\n    if (anchor.line === head.line) {\n      drawLineFor(anchor, head);\n      return;\n    }\n\n    if (comparePos(anchor, head) > 0) {\n      this.underlineText(cm, head, anchor);\n      return;\n    }\n\n    {\n      const anchorLine = anchor.line;\n      const headLine = head.line;\n\n      drawLineFor(anchor, { line: anchorLine, ch: Infinity });\n      let line = anchorLine + 1;\n      while (line < headLine) {\n        drawLineFor({ line, ch: 0 }, { line, ch: Infinity });\n        line++;\n      }\n      drawLineFor({ line: headLine, ch: 0 }, head);\n    }\n  }\n\n  psychEach() {\n    const { lcm, cm, line, ch } = this.hoveredPosition;\n    if (!cm) {\n      return;\n    }\n\n    {\n      // not hovering a word?: fallback to psych\n      let { anchor, head } = cm.findWordAt({ line, ch });\n      if (/[^a-zA-Z]/.test(cm.getRange(anchor, head))) {\n        return this.psych();\n      }\n    }\n\n    let anchorIndex = cm.indexFromPos({ line, ch }),\n        headIndex = anchorIndex;\n\n    const str = lcm.value;\n\n    const letter = c => /[a-zA-Z]/g.test(c);\n    const small = c => /[a-z]/g.test(c);\n    const big = c => /[A-Z]/g.test(c);\n\n    // scan left\n\n    let foundBig = big(str[anchorIndex]);\n    while (anchorIndex - 1 >= 0) {\n      const charToAdd = str[anchorIndex - 1];\n\n      if (!letter(charToAdd)) {\n        break;\n      }\n\n      if (foundBig && small(charToAdd)) {\n        break;\n      }\n\n      foundBig = big(charToAdd);\n      anchorIndex--;\n    }\n\n    // scan right\n\n    let foundSmall = small(str[headIndex]);\n    while (headIndex < str.length) {\n      const charToAdd = str[headIndex];\n\n      if (!letter(charToAdd)) {\n        break;\n      }\n\n      if (foundSmall && big(charToAdd)) {\n        break;\n      }\n\n      foundSmall = small(charToAdd);\n      headIndex++;\n    }\n\n    const anchor = cm.posFromIndex(anchorIndex);\n    const head = cm.posFromIndex(headIndex);\n    this.replaceSelectionWith(cm.getRange(anchor, head));\n  }\n\n  psychTo(char, inclusive) {\n    if (char === 'Enter') {\n      char = '\\n';\n    }\n\n    const { lcm, cm, line, ch } = this.hoveredPosition;\n    if (!cm) {\n      return;\n    }\n\n    let { anchor, head } = cm.findWordAt({ line, ch });\n\n    let headIndex = cm.indexFromPos(head);\n\n    const str = lcm.value;\n\n    while (headIndex < str.length) {\n      const charToAdd = str[headIndex];\n\n      if (char === charToAdd) {\n        if (inclusive) {\n          headIndex++;\n        }\n        break;\n      } else {\n        headIndex++;\n      }\n    }\n    head = cm.posFromIndex(headIndex);\n\n    this.replaceSelectionWith(cm.getRange(anchor, head));\n  }\n\n  findSmartAroundSelection(cm, anchor, head, inclusive) {\n    function asFromTo(anchor, head) {\n      if (comparePos(anchor, head) > 0) {\n        return [head, anchor];\n      } else {\n        return [anchor, head];\n      }\n    }\n\n    const [from, to] = asFromTo(anchor, head);\n\n    const fromIndex = cm.indexFromPos(from);\n    const toIndex = cm.indexFromPos(to);\n\n    const str = cm.getValue();\n\n    const matches = [...str.matchAll(/['\"`\\(\\)\\[\\]{}]/g)].map(match => ({ char: match[0], index: match.index }));\n\n    const {\n      isLeft,\n      isRight,\n      getLeft,\n      getRight\n    } = this.psychUtils;\n\n    let startIndex = 0;\n    let endIndex = str.length;\n    const stack = [];\n    for (let match of matches) {\n      const { char, index } = match;\n      const onLeftSide = index < fromIndex;\n      const onRightSide = toIndex <= index;\n\n      function pushOntoStack(m) {\n        m.onLeftSide = onLeftSide;\n        stack.push(m);\n      }\n\n      if (isRight(char)) {\n        if (stack.length > 0 && getLeft(char) === stack.last.char) {\n          const left = stack.pop();\n          if (onRightSide && left.onLeftSide) {\n            startIndex = left.index;\n            endIndex = index;\n            break;\n          }\n        } else {\n          if (isLeft(char)) {\n            // quotes as left delimiter\n            pushOntoStack(match);\n            continue;\n          } else {\n            // ignore non-matching right brackets\n            continue;\n          }\n        }\n      } else {\n        if (isLeft(char)) {\n          // left bracket\n          pushOntoStack(match);\n          continue;\n        } else {\n          lively.error(`match ${char} at position ${index} should never happen`);\n          continue;\n        }\n      }\n    }\n\n    if (inclusive) {\n      endIndex++;\n    } else {\n      startIndex++;\n    }\n\n    const start = cm.posFromIndex(startIndex);\n    const end = cm.posFromIndex(endIndex);\n    return { anchor: start, head: end };\n  }\n\n  psychInSmart(inclusive) {\n    const { cm, line, ch } = this.hoveredPosition;\n    if (!cm) {\n      return;\n    }\n\n    const pos = { line, ch };\n    const { anchor, head } = this.findSmartAroundSelection(cm, pos, pos, inclusive);\n\n    this.replaceSelectionWith(cm.getRange(anchor, head));\n  }\n\n  // cleanup\n  getLeftRightCharacters(char) {\n    if (/[']/.test(char)) {\n      return [\"'\", \"'\"];\n    }\n    if (/[\"]/.test(char)) {\n      return ['\"', '\"'];\n    }\n    if (/[`~]/.test(char)) {\n      return ['`', '`'];\n    }\n    if (/[\\(\\)90]/.test(char)) {\n      return ['(', ')'];\n    }\n    if (/[\\[\\]]/.test(char)) {\n      return ['[', ']'];\n    }\n    if (/[{}]/.test(char)) {\n      return ['{', '}'];\n    }\n    throw new Error(`char ${char} not supported for leftRight`);\n  }\n\n  scanLeftRight(char, inclusive) {}\n\n  psychIn(char, inclusive) {\n    if (/[^'\"`\\(\\)\\[\\]{}90~]/.test(char)) {\n      lively.warn(`char ${char} not supported`);\n      return;\n    }\n\n    const { lcm, cm, line, ch } = this.hoveredPosition;\n    if (!cm) {\n      return;\n    }\n\n    let anchorIndex = cm.indexFromPos({ line, ch }),\n        headIndex = anchorIndex;\n\n    const str = lcm.value;\n\n    const [left, right] = this.getLeftRightCharacters(char);\n    const {\n      isLeft,\n      isRight,\n      getLeft,\n      getRight\n    } = this.psychUtils;\n\n    // scan left\n    {\n      const stackLeft = [];\n      while (anchorIndex - 1 >= 0) {\n        const charToAdd = str[anchorIndex - 1];\n\n        if (charToAdd === left && stackLeft.last !== getRight(charToAdd)) {\n          break;\n        }\n\n        if (isRight(charToAdd)) {\n          stackLeft.push(charToAdd);\n        } else if (isLeft(charToAdd) && stackLeft.last === getRight(charToAdd)) {\n          stackLeft.pop();\n        }\n\n        anchorIndex--;\n      }\n    }\n\n    // scan right\n    {\n      const stackRight = [];\n      while (headIndex < str.length) {\n        const charToAdd = str[headIndex];\n\n        if (charToAdd === right && stackRight.last !== getLeft(charToAdd)) {\n          break;\n        }\n\n        if (isLeft(charToAdd)) {\n          stackRight.push(charToAdd);\n        } else if (isRight(charToAdd) && stackRight.last === getLeft(charToAdd)) {\n          stackRight.pop();\n        }\n\n        headIndex++;\n      }\n    }\n\n    if (inclusive) {\n      anchorIndex--;\n      headIndex++;\n    }\n    const anchor = cm.posFromIndex(anchorIndex);\n    const head = cm.posFromIndex(headIndex);\n    this.replaceSelectionWith(cm.getRange(anchor, head));\n  }\n\n  get psychUtils() {\n    const lrPairs = [{ left: \"'\", right: \"'\" }, { left: '\"', right: '\"' }, { left: '`', right: '`' }].concat([{ left: '(', right: ')' }, { left: '[', right: ']' }, { left: '{', right: '}' }]);\n\n    const isLeft = char => lrPairs.some(({ left }) => left === char);\n\n    const isRight = char => lrPairs.some(({ right }) => right === char);\n\n    const getLeft = char => {\n      const pair = lrPairs.find(({ right }) => right === char);\n      return pair && pair.left;\n    };\n\n    const getRight = char => {\n      const pair = lrPairs.find(({ left }) => left === char);\n      return pair && pair.right;\n    };\n\n    return {\n      lrPairs,\n\n      isLeft,\n      isRight,\n      getLeft,\n      getRight\n    };\n  }\n\n  get hoveredPosition() {\n    const pt = MousePosition.pt;\n    MousePosition.showPoint(pt);\n\n    const lcm = MousePosition.elementsFromPoint(pt).find(e => e.tagName === 'LIVELY-CODE-MIRROR');\n    if (!lcm) {\n      lively.warn('no hovered code-mirror found');\n      return {};\n    }\n    const cm = lcm.editor;\n    const { line, ch } = cm.coordsChar({ left: pt.x, top: pt.y }, \"window\");\n\n    return { lcm, cm, line, ch };\n  }\n\n  replaceSelectionWith(text) {\n    this.cm.replaceSelection(text, 'end');\n  }\n\n  get cm() {\n    return this.codeProvider.codeMirror;\n  }\n\n  get lcm() {\n    return this.codeProvider.livelyCodeMirror;\n  }\n  /*MD ## Slurping and Barfing MD*/\n\n  underlinePath(cm, path, color = 'black') {\n    const start = loc(path.node.loc.start).asCM();\n    const end = loc(path.node.loc.end).asCM();\n    this.underlineText(cm, start, end);\n  }\n\n  slurpOrBarf({ slurp = false, barf = false, forward }) {\n    const cm = this.codeProvider.codeMirror;\n    var getScrollInfo = () => {\n      return cm.getScrollInfo();\n    };\n\n    var setScrollInfo = scrollInfo => {\n      cm.scrollIntoView({\n        left: scrollInfo.left,\n        top: scrollInfo.top,\n        right: scrollInfo.left + scrollInfo.width,\n        bottom: scrollInfo.top + scrollInfo.height\n      });\n    };\n\n    const scrollInfo = getScrollInfo();\n    const selections = cm.listSelections();\n\n    const res = this.sourceCode.transformAsAST(({ types: t }) => ({\n      visitor: {\n        Program: programPath => {\n          debugger;\n          let path = this.getInnermostPathContainingSelection(programPath, range(selections.first));\n          let innerBlock = path.find(p => {\n\n            if (!p.isBlock()) {\n              return false;\n            }\n            if (barf && p.get('body').length === 0) {\n              // nothing to barf\n              return false;\n            }\n            return true;\n          });\n\n          if (!innerBlock) {\n            if (barf) {\n              lively.warn('nothing to barf');\n            } else {\n              lively.warn('no innerBlock found');\n            }\n            return;\n          }\n\n          let outerStatement = innerBlock.find(p => {\n            if (!(p.parentPath && p.parentPath.isBlock())) {\n              return false;\n            }\n            if (slurp) {\n              if (forward && !p.getNextSibling().node) {\n                return false;\n              }\n              if (!forward && !p.getPrevSibling().node) {\n                return false;\n              }\n            }\n            return true;\n          });\n\n          if (slurp) {\n            if (forward) {\n              const pathToSlurp = outerStatement.getNextSibling();\n              // this.underlinePath(cm, pathToSlurp);\n              // this.underlinePath(cm, innerBlock);\n              innerBlock.pushContainer('body', pathToSlurp.node);\n              pathToSlurp.remove();\n            } else {\n              const pathToSlurp = outerStatement.getPrevSibling();\n              this.underlinePath(cm, pathToSlurp);\n              this.underlinePath(cm, innerBlock);\n              this.underlinePath(cm, outerStatement);\n              debugger;\n              innerBlock.unshiftContainer('body', t.expressionStatement(t.identifier('slurped'\n              // pathToSlurp.node);\n              // pathToSlurp.remove();\n              )));\n            }\n          }\n          if (barf) {\n            if (forward) {\n              const pathToBarf = innerBlock.get('body').last;\n              // this.underlinePath(cm, pathToBarf);\n              // this.underlinePath(cm, outerStatement);\n              outerStatement.insertAfter(pathToBarf.node);\n              pathToBarf.remove();\n            } else {\n              const pathToBarf = innerBlock.get('body').first;\n              // this.underlinePath(cm, pathToBarf);\n              // this.underlinePath(cm, outerStatement);\n              outerStatement.insertBefore(pathToBarf.node);\n              pathToBarf.remove();\n            }\n          }\n        }\n      }\n    }));\n\n    this.sourceCode = res.code;\n\n    cm.setSelections(selections);\n    setScrollInfo(scrollInfo);\n  }\n\n  slurp(forward) {\n    this.slurpOrBarf({ slurp: true, forward });\n  }\n\n  barf(forward) {\n    this.slurpOrBarf({ barf: true, forward });\n  }\n\n  /*MD ## Navigation MD*/\n  /**\n   * Get the root path\n  */\n  get programPath() {\n    if (!this.myProgramPath && !this.parsingFailed) {\n      this.myProgramPath = this.programPathFor(this.sourceCode);\n      this.parsingFailed = !this.myProgramPath;\n    }\n    return this.myProgramPath;\n  }\n\n  programPathFor(code) {\n    var programPath = null;\n    try {\n      code.traverseAsAST({\n        Program(path) {\n          programPath = path;\n        }\n      });\n    } catch (err) {\n      return undefined;\n    }\n\n    return programPath;\n  }\n\n  get rootNode() {\n    return this.programPath && this.programPath.parent;\n  }\n\n  /**\n   * Invalidates old state on code change\n  */\n  codeChanged() {\n    this.myProgramPath = undefined;\n    this.parsingFailed = null;\n    this.finishedEnrichment = false;\n    this.memberAssignments = new Map();\n    this.aexprs = undefined;\n  }\n\n  get canParse() {\n    if (this.parsingFailed == null) this.programPath;\n    return !this.parsingFailed;\n  }\n\n  /** \n   * Return first child in depth first search that satisfies a condition\n   */\n  nextPath(startingPath, isValid) {\n    let pathToShow;\n\n    startingPath.traverse({\n      enter(path) {\n        if (!pathToShow && isValid(path)) {\n          pathToShow = path;\n          path.stop();\n        }\n      }\n    });\n\n    return pathToShow;\n  }\n\n  /**\n   * Return the last valid path that is generated by a given callback function on the previous path\n   */\n  getLastPath(startingPath, nextPathCallback) {\n    let pathToShow = startingPath;\n    while (true) {\n      let nextPath = nextPathCallback(pathToShow);\n      if (nextPath) {\n        pathToShow = nextPath;\n      } else {\n        break;\n      }\n    }\n\n    return pathToShow;\n  }\n\n  /**\n   * Returns the first child of a node or the node itself, if it has no children\n   */\n  getFirstChildOrSelf(startingPath) {\n    let child;\n    startingPath.traverse({\n      enter(path) {\n        if (!child) {\n          child = path;\n        }\n      }\n    });\n    return child || startingPath;\n  }\n\n  /**\n  * Returns the nearest path before the cursor location\n  */\n  getPathBeforeCursor(startingPath, anchor) {\n    const selectionStart = loc(anchor);\n    let foundPath;\n    startingPath.traverse({\n      exit(path) {\n        const pathLocation = path.node.loc;\n        const pathEnd = loc(pathLocation.end);\n        if (selectionStart.isBefore(pathEnd)) {\n          path.stop();\n          return;\n        }\n        foundPath = path;\n      }\n    });\n    return foundPath;\n  }\n\n  /**\n   * Returns the innermost node, that contains the selected text.\n   */\n  getInnermostPathContainingSelection(startingPath, selection) {\n    // go down to minimal selected node\n    const nextPathContainingCursor = (newStartingPath, selection) => {\n      return this.nextPath(newStartingPath, path => {\n        return range(path.node.loc).containsRange(selection);\n      });\n    };\n    return this.getLastPath(startingPath, prevPath => nextPathContainingCursor(prevPath, selection));\n  }\n\n  getSelectedPaths(programPath) {\n    return this.selectionRanges.map(selection => {\n      const pathContainingWholeSelection = this.getInnermostPathContainingSelection(programPath, selection);\n\n      //path already matches the selection\n      if (this.isPathExactlySelected(pathContainingWholeSelection, selection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        enter(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedStatements(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isStatement(pathContainingWholeSelection) && !t.isBlockStatement(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Statement(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc))) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  getSelectedExpressions(programPath) {\n    return this.selectionRanges.map(selection => {\n      //Replace with get surrounding statement?\n      const pathContainingWholeSelection = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      if (t.isExpression(pathContainingWholeSelection) && !t.isIdentifier(pathContainingWholeSelection)) {\n        return pathContainingWholeSelection;\n      }\n      //find children that match the selection\n      let selectedPaths = [];\n      pathContainingWholeSelection.traverse({\n        Expression(path) {\n          if (selection.containsPartsOfRange(range(path.node.loc)) && !t.isIdentifier(path)) {\n            selectedPaths.push(path);\n          }\n          path.skip();\n        }\n      });\n      return selectedPaths;\n    }).flat();\n  }\n\n  /** \n   * Takes the outermost node which corresponding selection range is minimal for containing the selected text.\n   * a      foo = bar\n   * --b    foo\n   *   --c  foo\n   * \n   * In this example, when 'foo' is selected, b will be returned, since it is the outermost node that contains the\n   * entire selection, but nothing more.\n   */\n  getOutermostPathContainingSelectionWithMinimalSelectionRange(startingPath, selection) {\n    var currentPath = this.getInnermostPathContainingSelection(startingPath, selection);\n    currentPath.findParent(path => {\n      if (selection.isEqual(range(path.node.loc))) {\n        currentPath = path;\n      }\n      return false;\n    });\n    return currentPath;\n  }\n\n  /**\n   * Array of all children in depth first search order\n   */\n  forwardList(parentPath) {\n    const linearizedPathList = [];\n    parentPath.traverse({\n      exit(path) {\n        linearizedPathList.push(path);\n      }\n    });\n    return linearizedPathList;\n  }\n\n  /**\n   * Array of all children in reversed depth first search order\n   */\n  backwardList(parentPath) {\n    const linearizedPathList = [];\n    parentPath.traverse({\n      enter(path) {\n        linearizedPathList.push(path);\n      }\n    });\n    return linearizedPathList.reverse();\n  }\n\n  /**\n   * select the selection range of the next ast node after the current selection that satisfies a given condition\n   * select previous selection instead of next, if reversed is set to true\n   */\n  selectNextASTNodeWith(condition, reversed) {\n    const programPath = this.programPath;\n    const pathList = reversed ? this.backwardList(programPath) : this.forwardList(programPath);\n\n    const maxPaths = this.selectionRanges.map(selection => {\n\n      const currentPath = this.getOutermostPathContainingSelectionWithMinimalSelectionRange(programPath, selection);\n\n      // do we fully select the current path?\n      if (selection.isEqual(range(currentPath.node.loc))) {\n        return this.getNextASTNodeInListWith(condition, pathList, currentPath);\n      } else {\n        return currentPath;\n      }\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  getFirstSelectedIdentifier(startPath) {\n    if (t.isIdentifier(startPath.node)) {\n      return startPath;\n    }\n    var first;\n    startPath.traverse({\n      Identifier(path) {\n        if (!first) {\n          first = path;\n          path.stop();\n        }\n      }\n    });\n    return first;\n  }\n\n  getFirstSelectedIdentifierWithName(startPath, name) {\n    if (t.isIdentifier(startPath.node, { name: name })) {\n      return startPath;\n    }\n    var first;\n    startPath.traverse({\n      Identifier(path) {\n        if (!first && t.isIdentifier(path.node, { name: name })) {\n          first = path;\n          path.stop();\n        }\n      }\n    });\n    return first;\n  }\n\n  getAllIdentifiers(startPath) {\n    var identifiers = [];\n    startPath.traverse({\n      Identifier(path) {\n        identifiers.push(path);\n      }\n    });\n    return identifiers;\n  }\n\n  getDeclaration(identifier) {\n    if (identifier.scope.hasBinding(identifier.node.name)) {\n      return identifier.scope.getBinding(identifier.node.name).path;\n    }\n  }\n\n  getBindingDeclarationIdentifierPath(binding) {\n    return this.getFirstSelectedIdentifierWithName(binding.path, binding.identifier.name);\n  }\n\n  getBindingsInFile(startPath) {\n    var identifier = this.getFirstSelectedIdentifier(startPath);\n    if (!identifier) return [];\n    const astBindings = this.getASTBinding(identifier);\n\n    if (astBindings) {\n      return astBindings;\n    }\n\n    return this.getClassBindings(identifier);\n  }\n\n  /**\n   * Returns all bindings of a given identifier\n   */\n  getASTBinding(identifier) {\n    if (identifier.scope.hasBinding(identifier.node.name)) {\n      const binding = identifier.scope.getBinding(identifier.node.name);\n      const identifierPaths = [...new Set([this.getBindingDeclarationIdentifierPath(binding), ...binding.referencePaths, ...binding.constantViolations.map(cv => this.getFirstSelectedIdentifierWithName(cv, binding.identifier.name))])];\n      if (identifierPaths.includes(identifier)) {\n        return identifierPaths;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Returns bindings of given identifier in its class\n   */\n  getClassBindings(identifier) {\n    if (t.isMemberExpression(identifier.parent)) {\n      if (t.isThisExpression(identifier.parent.object)) {\n        let classPath = this.getClassPath(this.programPath);\n        let methodPath = this.getMethodPath(classPath, identifier.node.name);\n        if (methodPath) {\n          return this.getClassMethodBindings(methodPath);\n        } else {\n          return this.getMemberBindings(identifier);\n        }\n      }\n    } else if (t.isClassMethod(identifier.parent)) {\n      return this.getClassMethodBindings(identifier.parentPath);\n    }\n  }\n\n  getClassMethodBindings(classMethod) {\n    var methodIdentifier;\n    classMethod.traverse({\n      Identifier(path) {\n        path.stop();\n        methodIdentifier = path;\n      }\n    });\n    return [methodIdentifier, ...this.getMemberBindings(methodIdentifier)];\n  }\n\n  /**\n   * if getUnbound is set to true, instead of getting all member Expressions with this (= that are bound) we only get those, that are unbound\n   */\n  getMemberBindings(identifier, getUnbound = false, startPath = this.programPath) {\n    var members = [];\n    startPath.traverse({\n      Identifier(path) {\n        if (t.isMemberExpression(path.parent) && path.node.name === identifier.node.name) {\n          if (getUnbound || t.isThisExpression(path.parent.object)) {\n            members.push(path);\n          }\n        }\n      }\n    });\n    return members;\n  }\n\n  getAllUnboundIdentifierNames(startPath = this.programPath) {\n    var unboundIdentifiers = [];\n    startPath.traverse({\n      Identifier(path) {\n        if (t.isMemberExpression(path.parent)) {\n          if (!t.isThisExpression(path.parent.object)) {\n            unboundIdentifiers.push(path);\n          }\n        }\n      }\n    });\n    return unboundIdentifiers.map(binding => binding.node.name).filter((value, index, self) => self.indexOf(value) === index);\n  }\n\n  getNextASTNodeInListWith(conditionFunc, pathList, path) {\n    const currentPathInList = pathList.find(pathInList => pathInList.node === path.node);\n    const currentIndex = pathList.indexOf(currentPathInList);\n    for (var i = currentIndex + 1; i < pathList.length; i++) {\n      if (conditionFunc(path, pathList[i])) {\n        return pathList[i];\n      }\n    }\n    return pathList[pathList.length - 1];\n  }\n\n  /** \n   * Select the text corresponding to the given nodes\n   */\n  selectNodes(nodes, selectStringContentsOnly = false) {\n    const ranges = nodes.map(node => {\n      let selectedRange = range(node.loc);\n      if (selectStringContentsOnly) {\n        //only select the contents, not the quotes around it \n        selectedRange.start._cmCharacter++;\n        selectedRange.end._cmCharacter--;\n      }\n      return selectedRange;\n    });\n    this.codeProvider.selections = ranges;\n  }\n\n  /** \n   * Select the text corresponding to the given paths\n   */\n  selectPaths(paths, selectStringContentsOnly = false) {\n    this.selectNodes(paths.map(path => path.node), selectStringContentsOnly);\n  }\n\n  /** \n   * Get the path for the first method with the given name\n   */\n  getMethodPath(programPath, name) {\n    let methodPath;\n    programPath.traverse({\n      ClassMethod(path) {\n        if (!methodPath && path.node.key.name == name) {\n          methodPath = path;\n        }\n      },\n      FunctionDeclaration(path) {\n        if (!methodPath && path.node.id.name == name) {\n          methodPath = path;\n        }\n      }\n    });\n    return methodPath;\n  }\n\n  /** \n   * Get the path of the first class\n   */\n  getClassPath(programPath) {\n    let classPath;\n    programPath.traverse({\n      ClassDeclaration(path) {\n        if (!classPath) {\n          classPath = path;\n        }\n      }\n    });\n    return classPath;\n  }\n\n  getColorLiterals() {\n    var pPath = this.programPath;\n    if (!pPath) return;\n    let colorPaths = [];\n    const colorRegex = /(0[xX]|#)[0-9a-fA-F]{6}$/g;\n    pPath.traverse({\n      StringLiteral(path) {\n        if (path.node.value.match(colorRegex)) {\n          colorPaths.push(path);\n        }\n      }\n    });\n    return colorPaths;\n  }\n\n  /*MD ### Shortcuts MD*/\n\n  expandSelectionOLD() {\n    // lively.notify('foo')\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  expandSelection() {\n    // lively.notify('foo')\n    const maxPaths = this.selectionRanges.map(selection => {\n      const startingPath = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      'foo';\n      \"foo\".bar;\n      var foo;\n      `foo ${foo} bar`;\n      let resultSelection;\n\n      // go up again\n      startingPath.find(path => {\n        function fullySelected(path) {\n          return range(path.node.loc).isEqual(selection);\n        }\n\n        // lively.warn(path.inList);\n        //     lively.openInspector(path);\n        if (fullySelected(path)) {\n          return false;\n        } else {\n          if (path.isTemplateLiteral()) {\n            // are we in a template element notation\n            if (path.get('expressions').find(p => {\n              var r = range(p.node.loc)\n              r.start._cmCharacter -= 2;\n              r.end._cmCharacter++;\n              if (r.strictlyContainsRange(selection)) {\n                resultSelection = r\n                return true\n              }\n            })) {\n              return true\n            }\n          }\n\n          if (path.isStringLiteral() || path.isTemplateLiteral()) {\n            resultSelection = range(path.node.loc);\n            resultSelection.start._cmCharacter++;\n            resultSelection.end._cmCharacter--;\n\n            // did selection expand?\n            if (!resultSelection.isEqual(selection)) {\n              return true;\n            }\n          }\n\n          if (path.isTemplateElement()) {\n            return false;\n          }\n\n          resultSelection = range(path.node.loc);\n\n          return true;\n        }\n        // comparePos(a, b)\n\n        // return range(path.node.loc).strictlyContainsRange(selection);\n      }) || startingPath;\n\n      return resultSelection || selection;\n    });\n\n    // const nodes = maxPaths.map(path => path.node);\n    // const ranges = nodes.map(node => {\n    //   let selectedRange = range(node.loc);\n    //   if (false) {\n    //     //only select the contents, not the quotes around it \n    //   }\n    //   return selectedRange;\n    // });\n    this.codeProvider.selections = maxPaths;\n    // this.cm.setSelections(maxPaths)\n  }\n\n  reduceSelection() {\n    const maxPaths = this.selectionRanges.map(selection => {\n      const pathToShow = this.getInnermostPathContainingSelection(this.programPath, selection);\n\n      return this.getFirstChildOrSelf(pathToShow);\n    });\n\n    this.selectPaths(maxPaths);\n  }\n\n  selectNextASTChild(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => {\n      return t.isIdentifier(nextNode) || t.isLiteral(nextNode) || t.isThisExpression(nextNode) || t.isSuper(nextNode) || t.isDebuggerStatement(nextNode);\n    }, reversed);\n  }\n\n  selectNextASTNodeLikeThis(reversed) {\n    return this.selectNextASTNodeWith((currentNode, nextNode) => currentNode.type == nextNode.type, reversed);\n  }\n\n  selectNextReference(reversed) {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);if (bindings) {\n      let sortedBindings = [...bindings].sort((a, b) => a.node.start - b.node.start);\n      let index = sortedBindings.indexOf(selectedPath);\n      index += reversed ? -1 : 1;\n      index = (index + sortedBindings.length) % sortedBindings.length;\n      this.selectPaths([sortedBindings[index]]);\n    }\n  }\n\n  async selectDeclaration() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) {\n      return;\n    }\n    const identName = identifier.node.name;\n\n    const declaration = await this.getDeclaration(identifier);\n    //needs smarter selection of source\n    if (declaration && !t.isImportSpecifier(declaration)) {\n      this.selectPaths([declaration]);\n    } else {\n      let classPath = this.getClassPath(this.programPath);\n      let methodPath = this.getMethodPath(classPath, identName);\n      if (methodPath) {\n        this.selectNodes([methodPath.node.key]);\n      } else {\n\n        // Find the declaration in other files and open the possible files in a new browser at the correct location\n        const classUrls = await this.getCorrespondingClasses(identName).then(arr => arr.map(cl => cl.url));\n        const functionUrls = await this.getFunctionExportURLs(identName);\n        const urls = classUrls.concat(functionUrls);\n\n        urls.forEach(url => lively.openBrowser(url, true).then(container => {\n          container.asyncGet(\"#editor\").then(async livelyEditor => {\n            let newCodeMirror = livelyEditor.livelyCodeMirror();\n            var cm = await livelyEditor.awaitEditor();\n            newCodeMirror.astCapabilities(cm).then(ac => {\n              ac.selectPaths([ac.getMethodPath(ac.programPath, identName)]);\n            });\n          });\n        }));\n      }\n    }\n    /**\n      TODO: if our dependencies don't have the method, we can search all classes    \n      Also: do not only search for methods, but for members too (even though they are technically not bindings?)\n    */\n  }\n\n  async rename() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    var identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (!identifier) return;\n    const astBindings = this.getASTBinding(identifier);\n\n    // If there is a binding in the current AST, all references get selected for renaming\n    if (astBindings) {\n      this.selectPaths(astBindings);\n      return;\n    }\n\n    /**\n     * If not: the user gets a list of all possible occurrences and can select entries for renaming and can choose the new name.\n     * Afterwards the selected occurrences in other files get refactored in the background.\n     */\n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\n\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setAdditionalInput(\"Name\", \"enter new name\");\n    comp.setTitle(\"Rename \" + identifier.node.name);\n    const references = await comp.selectItems(bindingItems);\n\n    const newName = comp.getAdditionalInput().camelCase();\n    if (newName === \"\") return;\n\n    for (const reference of references) {\n      const code = await fetch(reference.url).then(r => r.text());\n\n      const codeLines = code.split(\"\\n\");\n\n      String.prototype.replaceBetween = function (start, end, what) {\n        return this.substring(0, start) + what + this.substring(end);\n      };\n      codeLines[reference.line] = codeLines[reference.line].replaceBetween(reference.ch, reference.ch + identifier.node.name.length, newName);\n\n      const newCode = codeLines.join(\"\\n\");\n      await lively.files.saveFile(reference.url, newCode);\n      await lively.reloadModule(reference.url);\n      await System.import(reference.url);\n    }\n  }\n\n  selectBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    const bindings = this.getBindingsInFile(selectedPath);\n    if (bindings) {\n      this.selectPaths(bindings);\n    }\n  }\n\n  async printAllBindings() {\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n\n    // const bindings = this.getBindings(selectedPath);\n    var identifier = this.getFirstSelectedIdentifier(selectedPath);\n\n    // find classes that contain the method\n    const bindingItems = await this.getPossibleBindingsAcrossFiles(identifier);\n\n    this.openReferencesMenu(bindingItems, identifier.node.name);\n  }\n\n  /**\n   * Uses the FileIndex to look for possible bindings in other files and returns an array containing elements with the name of found files, their urls and the line and column of the occurrence.\n   */\n  async getPossibleBindingsAcrossFiles(identifier) {\n    let index = await FileIndex.current();\n    let ids = await index.db.files.filter(file => {\n      if (!file.unboundIdentifiers) return false;\n      return file.unboundIdentifiers.some(id => id.name == identifier.name);\n    }).toArray();\n    const bindingItems = [];\n\n    for (const id of ids) {\n      const code = await fetch(id.url).then(r => r.text());\n      const program = this.programPathFor(code);\n      for (const reference of this.getMemberBindings(identifier, true, program)) {\n        const line = reference.node.loc.start.line - 1;\n        const ch = reference.node.loc.start.column;\n        bindingItems.push({ id: id.url.substring(id.url.lastIndexOf(\"/\") + 1) + \": \" + line, url: id.url, line, ch });\n      }\n    }\n\n    return bindingItems;\n  }\n\n  async openReferencesMenu(ids, identifierName) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"References of \" + identifierName);\n    return comp.selectItems(ids);\n  }\n\n  async findImports() {\n    let functions, classes, identName;\n    const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n    const identifier = this.getFirstSelectedIdentifier(selectedPath);\n    if (identifier) {\n      identName = identifier.node.name;\n      functions = await this.getFunctionExportURLs(identName);\n      classes = await this.getCorrespondingClasses(identName);\n    }\n    return { identName, functions, classes };\n  }\n  /*MD ## Factoring Menu MD*/\n\n  /*MD ### Factoring Menu Helper Methods MD*/\n\n  // returns innermostDescribePath \n  isInDescribe(path) {\n    let possiblePath = this.isIn(\"CallExpression\", path, \"describe\");\n\n    while (possiblePath !== null) {\n      if (possiblePath.node && possiblePath.node.callee.name === \"describe\") {\n        break;\n      }\n      possiblePath = this.isIn(\"CallExpression\", possiblePath.parentPath, \"describe\");\n    }\n    return possiblePath;\n  }\n\n  // returns a parentPath if path is somewhere in a path with a type stored in type\n  // or null if no type matches\n  // type can be a single type string or an array of type strings\n  isIn(type, path) {\n    while (path !== null) {\n      if (this.isDirectlyIn(type, path)) {\n        return path;\n      }\n      path = path.parentPath;\n    }\n    return null;\n  }\n\n  // returns if path is directly in a path with a type stored in type\n  // type can be a single type string or an array of type strings \n  isDirectlyIn(type, path) {\n    if (type instanceof Array) {\n      return type.map(elem => this.isDirectlyIn(elem, path)).reduce((accu, elem) => accu || elem, false);\n    }\n    return path.node && path.node.type === type;\n  }\n\n  /*MD ## Color Picker MD*/\n\n  updateColor(currentLocation, color) {\n    var location = { anchor: currentLocation, head: currentLocation };\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.getInnermostPathContainingSelection(programPath, range(location)); //this.getPathBeforeCursor(programPath, currentLocation);\n          if (t.isStringLiteral(path.node)) {\n            path.node.value = color;\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n  }\n  /*MD ## Generations MD*/\n\n  /*MD ### Generate Testcase / Class / get / set / HTML accessors MD*/\n\n  async openHTMLAccessorsMenu(ids, initialSelectionState) {\n    let comp = await lively.openComponentInWindow(\"lively-code-occurence-selection\");\n    comp.focus();\n    comp.setTitle(\"Select HTML Accessors to generate\");\n    return comp.selectItems(ids, initialSelectionState);\n  }\n\n  getExistingAccessors() {\n    let classMethodIdentifier = [];\n    this.programPath.traverse({\n      ExportDefaultDeclaration(path) {\n        if (path && path.node.declaration && path.node.declaration.type == \"ClassDeclaration\") {\n          classMethodIdentifier = path.node.declaration.body.body.map(elem => elem.key.name);\n          path.stop();\n        }\n      }\n    });\n    return classMethodIdentifier;\n  }\n\n  async generateHTMLAccessors() {\n    const ids = await this.compileListOfIDs();\n    if (ids.length === 0) {\n      return;\n    }\n\n    let existingMethods = this.getExistingAccessors();\n    let initialSelectionState = ids.map(elem => existingMethods.includes(this.generateMethodNameFromProperty(elem.id)));\n    const selectedItems = await this.openHTMLAccessorsMenu(ids, initialSelectionState);\n\n    if (selectedItems.length === 0) {\n      return;\n    }\n    lively.warn(`${selectedItems.length} Accessors generated`);\n\n    selectedItems.forEach(item => {\n      this.generateCodeFragment(item.id, name => this.compileHTMLGetter(name));\n      const selectedPath = this.getInnermostPathContainingSelection(this.programPath, this.firstSelection);\n      let line = selectedPath.parent.loc.end.line + 1;\n      this.codeProvider.cursor = loc({ line, ch: 0 });\n    });\n  }\n\n  // collects all html element ids of the current file\n  async compileListOfIDs() {\n    const htmlURI = this.codeProvider.htmlURI;\n    let html = await htmlURI.fetchText();\n\n    if (html === \"File not found!\\n\") {\n      lively.warn(\"There is no HTML associated with this file.\");\n      return [];\n    }\n\n    let tmp = <div></div>;\n    tmp.innerHTML = html;\n    let ids = tmp.childNodes[0].content.querySelectorAll(\"[id]\").map(ea => ea.id);\n\n    const htmlLines = html.split(\"\\n\");\n\n    const idsWithLocation = [];\n    for (const id of ids) {\n      for (const line of htmlLines) {\n        const indexOfId = line.indexOf(\"id=\\\"\" + id + \"\\\"\");\n        if (indexOfId !== -1) {\n          idsWithLocation.push({ id, url: htmlURI, line: htmlLines.indexOf(line), ch: indexOfId + 4 });\n          break;\n        }\n      }\n    }\n    return idsWithLocation;\n  }\n\n  generateTestCase() {\n    this.generateCodeFragment(\"ExplainWhatIsTested\", id => this.compileTestCase(id.identifier));\n  }\n\n  generateGetter() {\n    this.generateCodeFragment(\"NameThisGetter\", id => this.compileGetter(id.identifier));\n  }\n\n  generateSetter() {\n    this.generateCodeFragment(\"NameThisSetter\", id => this.compileSetter(id.identifier));\n  }\n\n  generateClass() {\n    this.generateCodeFragment(\"SetClassName\", id => this.compileClass(id.identifier));\n  }\n\n  async generateCodeFragment(identifier, replacementGenerator) {\n    const scrollInfo = this.scrollInfo;\n    const selection = this.firstSelection;\n\n    var identifierObject = { identifier };\n\n    var generatedCode;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let pathBefore = this.getPathBeforeCursor(programPath, selection.start);\n          let pathWithin = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n          generatedCode = replacementGenerator(identifierObject);\n          if (pathBefore === undefined) {\n            // we're on top of the program\n            pathWithin.unshiftContainer('body', generatedCode);\n          } else if (this.isDirectlyIn(pathWithin.type, pathBefore.parentPath)) {\n            // we're inside of a code block, but not in the first line\n            pathBefore.insertAfter(generatedCode);\n          } else {\n            // we're in the first line of a block\n            pathWithin.unshiftContainer('body', generatedCode);\n          }\n        }\n      }\n    })).code;\n\n    // after code generation, we have to find the generated code another time to be able to select it for renaming\n    var pathToSelect;\n    this.programPath.traverse({\n      StringLiteral(path) {\n        if (!pathToSelect && path.node.value == identifierObject.identifier) {\n          pathToSelect = path;\n        }\n      },\n      Identifier(path) {\n        if (path.node.name == identifierObject.identifier) {\n          pathToSelect = path;\n          path.stop();\n        }\n      }\n    });\n    this.selectPaths([pathToSelect], true);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  compileTestCase(explanation) {\n    return template(\"it(EXP, () => {\\n\" + \"let put = 'code here';\" + \"})\")({\n      EXP: t.stringLiteral(explanation)\n    });\n  }\n\n  compileGetter(propertyName) {\n    return t.classMethod(\"get\", t.identifier(propertyName), [], t.blockStatement([t.returnStatement(t.memberExpression(t.thisExpression(), t.identifier(\"internalPropertyName\")))]));\n  }\n\n  compileSetter(propertyName) {\n    return t.classMethod(\"set\", t.identifier(propertyName), [t.Identifier(\"newValue\")], t.blockStatement([t.expressionStatement(t.assignmentExpression(\"=\", t.memberExpression(t.thisExpression(), t.identifier(\"internalPropertyName\")), t.identifier(\"newValue\")))]));\n  }\n\n  compileClass(className) {\n    return t.classDeclaration(t.identifier(className), null, t.classBody([t.classMethod(\"constructor\", t.Identifier(\"constructor\"), [], t.blockStatement([]))]), []);\n  }\n\n  compileHTMLGetter(property) {\n    var propertyName = property.identifier;\n    var methodName = this.generateMethodNameFromProperty(propertyName);\n    property.identifier = methodName;\n    return t.classMethod(\"get\", t.identifier(methodName), [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.thisExpression(), t.identifier(\"get\")), [t.stringLiteral(\"#\" + propertyName)]))]));\n  }\n\n  generateMethodNameFromProperty(name) {\n    return name.camelCase();\n  }\n\n  /*MD ### Generate Import MD*/\n\n  /**\n   * Converts the selected expression to a member expression and adds an import to the file if it doesn't already exist.\n   */\n  addImport(url, importName, isFunction) {\n    const selection = this.firstSelection;\n    const scrollInfo = this.scrollInfo;\n    this.sourceCode = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Program: programPath => {\n          let existingImportStatement = this.nextPath(programPath, path => {\n            return t.isImportDeclaration(path) && path.node.source.value == url;\n          });\n          let selectedPath = this.getInnermostPathContainingSelection(programPath, selection);\n          if (!existingImportStatement) {\n            let importStatement = t.importDeclaration([t.importSpecifier(t.identifier(importName), t.identifier(importName))], t.stringLiteral(url));\n            programPath.node.body.unshift(importStatement);\n          } else if (!existingImportStatement.node.specifiers.some(spec => spec.imported.name == importName)) {\n            existingImportStatement.node.specifiers.push(t.identifier(importName));\n          }\n          if (!isFunction) {\n            selectedPath.replaceWith(t.memberExpression(t.identifier(importName), t.identifier(selectedPath.node.name)));\n          }\n        }\n      }\n    })).code;\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Transformations MD*/\n\n  /*MD ### Extract Method MD*/\n  findParameters(identifiers, surroundingMethod, actualSelections) {\n    return identifiers.filter(identifier => {\n      return this.needsToBeParameter(identifier, surroundingMethod);\n    }).filter(identifier => {\n      const bindingPath = identifier.scope.getBinding(identifier.node.name).path;\n      return !this.isSelected(bindingPath, actualSelections);\n    }).map(identifier => {\n      return this.getBindingDeclarationIdentifierPath(identifier.scope.getBinding(identifier.node.name)).node;\n    });\n  }\n\n  shouldBeAsync(content) {\n    let hasAwait = false;\n    content.forEach(startPath => {\n      if (t.isAwaitExpression(startPath.node)) {\n        hasAwait = true;\n      } else {\n        startPath.traverse({\n          AwaitExpression(path) {\n            hasAwait = true;\n            path.stop();\n          }\n        });\n      }\n    });\n\n    return hasAwait;\n  }\n\n  couldBeStatic(content) {\n    let hasThis = false;\n    content.forEach(startPath => {\n      startPath.traverse({\n        ThisExpression(path) {\n          hasThis = true;\n          path.stop();\n        }\n      });\n    });\n\n    return !hasThis;\n  }\n\n  needsToBeParameter(identifier, surroundingMethod) {\n    return identifier.scope.hasBinding(identifier.node.name) && !surroundingMethod.parentPath.scope.hasBinding(identifier.node.name);\n  }\n\n  findReturnValues(identifiers, surroundingMethod, actualSelections) {\n    const bindings = [...new Set(identifiers.filter(identifier => {\n      return identifier.scope.hasBinding(identifier.node.name) && !surroundingMethod.parentPath.scope.hasBinding(identifier.node.name);\n    }).map(identifier => {\n      return identifier.scope.getBinding(identifier.node.name);\n    }))];\n\n    return bindings.filter(binding => {\n      const declarationInSelection = this.isSelected(binding.path, actualSelections);\n      const constantViolationInSelection = binding.constantViolations.some(constantViolation => this.isSelected(constantViolation, actualSelections));\n      const referenceOutsideSelection = binding.referencePaths.some(reference => !this.isSelected(reference, actualSelections));\n\n      return this.needsToBeReturned(declarationInSelection, constantViolationInSelection, referenceOutsideSelection);\n    }).map(binding => {\n      const constantViolationOutsideSelection = binding.constantViolations.some(constantViolation => !this.isSelected(constantViolation, actualSelections));\n      return { node: this.getBindingDeclarationIdentifierPath(binding).node, declaredInExtractedCode: this.isSelected(binding.path, actualSelections), constantViolationOutsideSelection };\n    });\n  }\n\n  needsToBeReturned(declarationInSelection, constantViolationInSelection, referenceOutsideSelection) {\n    return !declarationInSelection && constantViolationInSelection || (constantViolationInSelection || declarationInSelection) && referenceOutsideSelection;\n  }\n\n  createMethod(content, parameter, returnValues, scope, extractingExpression, shouldBeAsync, shouldBeStatic) {\n    if (extractingExpression && returnValues.length > 0) {\n      lively.warn(\"Unable to extract an expression, that assigns something to variables used outside the expression.\");\n    }\n    var returnStatement;\n    returnValues.forEach(returnValue => returnValue.returnIdentifier = returnValue.declaredInExtractedCode ? returnValue.node : t.identifier(returnValue.node.name + \"_return\"));\n    if (returnValues.length == 1) {\n      returnStatement = t.returnStatement(returnValues[0].node);\n    } else if (returnValues.length > 1) {\n      returnStatement = t.returnStatement(t.objectExpression(returnValues.map(i => t.objectProperty(i.returnIdentifier, i.node, false, true))));\n    }\n\n    var methodContent = content.map(p => {\n      //remove formatting for proper re-formatting\n      p.node.loc = null;\n      p.node.start = null;\n      p.node.end = null;\n      return p.node;\n    });\n    if (returnStatement) {\n      methodContent.push(returnStatement);\n    } else if (extractingExpression) {\n      methodContent = [t.returnStatement(content[0].node)];\n    }\n    const newMethod = t.classMethod(\"method\", t.identifier(\"HopefullyNobodyEverUsesThisMethodName\"), parameter, t.blockStatement(methodContent));\n    newMethod.async = shouldBeAsync;\n    newMethod.static = shouldBeStatic;\n    scope.insertAfter(newMethod);\n    for (let i = 0; i < content.length - 1; i++) {\n      content[i].remove();\n    }\n    var methodCall;\n    var callExpression = t.callExpression(t.identifier(\"this.HopefullyNobodyEverUsesThisMethodName\"), parameter);\n    if (shouldBeAsync) {\n      lively.warn(\"Extracting async method. This could change the control flow.\");\n      callExpression = t.awaitExpression(callExpression);\n    }\n    if (returnValues.length == 1) {\n      if (returnValues[0].declaredInExtractedCode) {\n        const variableType = returnValues[0].constantViolationOutsideSelection ? \"var\" : \"const\";\n        methodCall = [t.variableDeclaration(variableType, [t.variableDeclarator(returnValues[0].node, callExpression)])];\n      } else {\n        methodCall = [t.expressionStatement(t.assignmentExpression(\"=\", returnValues[0].node, callExpression))];\n      }\n    } else if (returnValues.length > 1) {\n      const objectPattern = t.objectPattern(returnValues.map(i => t.objectProperty(i.returnIdentifier, i.returnIdentifier, false, true)));\n      methodCall = [t.variableDeclaration(\"const\", [t.variableDeclarator(objectPattern, callExpression)])];\n      returnValues.forEach(returnStatement => {\n        if (returnStatement.node != returnStatement.returnIdentifier) {\n          methodCall.push(t.expressionStatement(t.assignmentExpression(\"=\", returnStatement.node, returnStatement.returnIdentifier)));\n        }\n      });\n    } else {\n      methodCall = [callExpression];\n    }\n    content[content.length - 1].replaceWithMultiple(methodCall);\n  }\n\n  async extractMethod() {\n    const scrollInfo = this.scrollInfo;\n    const transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const extraction = this.selectMethodExtraction(programPath);\n          if (!extraction) return;\n          const {\n            selectedPaths,\n            extractingExpression,\n            actualSelections\n          } = extraction;\n\n          const identifiers = selectedPaths.map(this.getAllIdentifiers).flat();\n          let surroundingMethod = selectedPaths[0].find(parent => {\n            return parent.node.type == \"ClassMethod\";\n          });\n          var shouldBeStatic = this.couldBeStatic(selectedPaths);\n          if (!surroundingMethod) {\n            surroundingMethod = selectedPaths[selectedPaths.length - 1];\n          } else {\n            shouldBeStatic = surroundingMethod.node.static;\n          }\n          const shouldBeAsync = this.shouldBeAsync(selectedPaths);\n          const parameters = this.findParameters(identifiers, surroundingMethod, actualSelections);\n          const returnValues = this.findReturnValues(identifiers, surroundingMethod, actualSelections);\n          this.createMethod(selectedPaths, [...new Set(parameters)], returnValues, surroundingMethod, extractingExpression, shouldBeAsync, shouldBeStatic);\n        }\n      }\n    }));\n    this.sourceCode = transformed.code;\n    this.scrollTo(scrollInfo);\n    const pathsToSelect = [];\n    this.programPath.traverse({\n      Identifier(path) {\n        if (path.node.name == \"HopefullyNobodyEverUsesThisMethodName\") {\n          pathsToSelect.push(path);\n        }\n      }\n    });\n    this.selectPaths(pathsToSelect);\n  }\n\n  /*MD ### Extract Variable MD*/\n\n  selectMethodExtraction(programPath, silent = false) {\n    var selectedPaths = this.getSelectedStatements(programPath);\n    var extractingExpression = false;\n\n    if (selectedPaths.length == 0) {\n      var expressions = this.getSelectedExpressions(programPath);\n      if (expressions.length > 1) {\n        if (!silent) lively.warn('You cannot extract multiple statements at once. Select statements or a single expression!');\n        return;\n      } else if (expressions.length == 0) {\n        if (!silent) lively.warn('Select statements or an expression to extract!');\n        return;\n      } else {\n        selectedPaths = expressions;\n        extractingExpression = true;\n      }\n    }\n\n    const actualSelections = selectedPaths.map(path => {\n      return range(path.node.loc);\n    });\n    return {\n      selectedPaths,\n      extractingExpression,\n      actualSelections\n    };\n  }\n\n  async extractExpressionIntoLocalVariable() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(({ types: t }) => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n\n              path.find(p => {\n                const parentPath = p.parentPath;\n                if (!parentPath) {\n                  return false;\n                }\n\n                function ensureBlock(body) {\n                  if (!body.node) return false;\n\n                  if (body.isBlockStatement()) {\n                    return false;\n                  }\n\n                  const statements = [];\n                  if (body.isStatement()) {\n                    statements.push(body.node);\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else if (body.parentPath.isArrowFunctionExpression() && body.isExpression()) {\n                    statements.push(t.returnStatement(body.node));\n                    const blockNode = t.blockStatement(statements);\n                    body.replaceWith(blockNode);\n                    return true;\n                  } else {\n                    throw new Error(\"I never thought this was even possible.\");\n                  }\n                }\n\n                const targetLocation = path.getPathLocation();\n                const blockLocation = p.getPathLocation();\n                if (p.parentKey === 'body' && (parentPath.isFor() || parentPath.isWhile())) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if (p.parentKey === 'body' && parentPath.isFunction()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0].argument' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n                if ((p.parentKey === 'consequent' || p.parentKey === 'alternate') && parentPath.isIfStatement()) {\n                  const becameABlock = ensureBlock(p);\n                  if (becameABlock) {\n                    pathLocationToBeExtracted = blockLocation + '.body[0]' + targetLocation.replace(blockLocation, '');\n                  }\n                  return true;\n                }\n              });\n\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No Expression to extract found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          let value = '';\n          path.traverse({\n            Identifier(p) {\n              value += '-' + p.node.name;\n            }\n          });\n          if (value.length > 0) {\n            // #TODO: ensure unique identifier\n            value = value.camelCase();\n          } else {\n            value = path.scope.generateUidIdentifier('temp').name;\n          }\n          const identifier = t.Identifier(value);\n          const decl = template('const ID = INIT;')({\n            ID: identifier,\n            INIT: path.node\n          });\n\n          let referree = t.Identifier(value);\n\n          path.replaceWith(referree);\n          const insertedDeclaration = path.getStatementParent().insertBefore(decl)[0];\n          const insertedDeclarationIdentifier = insertedDeclaration.get('declarations')[0].get('id');\n\n          pathLocationsToSelect.push(insertedDeclarationIdentifier.getPathLocation());\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.scrollTo(scrollInfo);\n  }\n\n  async inlineLocalVariable(foo) {\n    const scrollInfo = this.scrollInfo;\n    let exitedEarly = false;\n\n    const pathLocationsToSelect = [];\n    debugger;\n    let transformed = this.sourceCode.transformAsAST(({ types: t, template }) => ({\n      visitor: {\n        Program: programPath => {\n\n          const selectedPath = this.getInnermostPathContainingSelection(programPath, this.firstSelection);\n\n          const identifier = this.getFirstSelectedIdentifier(selectedPath);\n          if (!identifier) {\n            lively.warn('no identifier selected');\n            exitedEarly = true;\n            return;\n          }\n\n          const name = identifier.node.name;\n          if (!identifier.scope.hasBinding(name)) {\n            lively.warn('no binding found for ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          let binding = identifier.scope.getBinding(name);\n          if (!binding) {\n            lively.warn('selected identifier is not referencing a variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          if (!['var', 'let', 'const'].includes(binding.kind)) {\n            lively.warn('binding for \"' + name + '\" is of kind \"' + binding.kind + '\" but should be any of \"var\", \"let\", or \"const\"');\n            exitedEarly = true;\n            return;\n          }\n\n          const constantViolations = binding.constantViolations.map(cv => this.getFirstSelectedIdentifierWithName(cv, binding.identifier.name));\n          if (constantViolations.length > 0) {\n            lively.warn('cannot inline because there is a constant violation for variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          const declarationIdentifierPath = this.getBindingDeclarationIdentifierPath(binding);\n          if (!declarationIdentifierPath.parentPath.isVariableDeclarator()) {\n            lively.warn('declaration is probably in a destructuring');\n            exitedEarly = true;\n            return;\n          }\n\n          const referencePaths = binding.referencePaths;\n          if (referencePaths.length === 0) {\n            lively.warn('variable \"' + name + '\" is never referenced');\n            exitedEarly = true;\n            return;\n          }\n\n          const identifierPaths = [declarationIdentifierPath, ...referencePaths, ...constantViolations];\n          if (!identifierPaths.includes(identifier)) {\n            lively.warn('selected identifier is not referencing a variable ' + name);\n            exitedEarly = true;\n            return;\n          }\n\n          const variableDeclarator = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclarator());\n          const variableDeclaration = declarationIdentifierPath.findParent(parentPath => parentPath.isVariableDeclaration());\n          const initPath = variableDeclarator.get('init');\n\n          // remove declaration\n          if (variableDeclaration.get('declarations').length === 1) {\n            variableDeclaration.remove();\n          } else {\n            variableDeclarator.remove();\n          }\n\n          // inline declaration\n          referencePaths.forEach(p => {\n            pathLocationsToSelect.push(p.getPathLocation());\n          });\n          referencePaths.forEach(p => {\n            p.replaceWith(initPath.node);\n          });\n          const o = { a: 42, b: 17 };\n        }\n      }\n    }));\n\n    if (exitedEarly) {\n      return;\n    }\n\n    this.sourceCode = transformed.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n    this.selectPaths(pathsToSelect);\n\n    this.scrollTo(scrollInfo);\n  }\n\n  async wrapExpressionIntoActiveExpression() {\n    const selection = this.firstSelection;\n    let done = false;\n\n    const scrollInfo = this.scrollInfo;\n\n    let pathLocationToBeExtracted;\n    const res = this.sourceCode.transformAsAST(() => ({\n      visitor: {\n        Expression: path => {\n          if (!done) {\n            const isSelectedPath = this.isPathExactlySelected(path, selection);\n            if (isSelectedPath) {\n              pathLocationToBeExtracted = path.getPathLocation();\n              done = true;\n            }\n          }\n        }\n      }\n    }));\n\n    if (!pathLocationToBeExtracted) {\n      lively.warn('No `Expression` to wrap found.');\n      return;\n    }\n\n    const pathLocationsToSelect = [];\n    const resultExtracted = res.code.transformAsAST(({ template }) => ({\n      visitor: {\n        Program: programPath => {\n          const path = this.pathByLocationFromProgram(programPath, pathLocationToBeExtracted);\n          const ae = template('aexpr(() => EXPR)')({\n            EXPR: path.node\n          }).expression;\n\n          path.replaceWith(ae);\n\n          pathLocationsToSelect.push(path.getPathLocation());\n        }\n      }\n    }));\n    this.sourceCode = resultExtracted.code;\n\n    const pathsToSelect = this.pathLocationsToPathes(pathLocationsToSelect);\n\n    this.selectPaths(pathsToSelect);\n    this.scrollTo(scrollInfo);\n  }\n\n  /*MD ## Accessors MD*/\n\n  get sourceCode() {\n    return this.codeProvider.code;\n  }\n  set sourceCode(text) {\n    this.codeProvider.code = text;\n    this.codeChanged();\n    return this.codeProvider.code;\n  }\n\n  get scrollInfo() {\n    return this.codeProvider.scrollInfo;\n  }\n\n  scrollTo(scrollInfo) {\n    this.codeProvider.scrollInfo = scrollInfo;\n  }\n\n  /*MD ## Utilities MD*/\n\n  isSelected(path, selections = null) {\n    if (!selections) {\n      selections = this.selectionRanges;\n    }\n    const pathRange = range(path.node.loc);\n    for (const selection of selections) {\n      if (selection.containsRange(pathRange)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  isPathExactlySelected(path, selection) {\n    return selection.isEqual(range(path.node.loc));\n  }\n\n  pathByLocationFromProgram(programPath, location) {\n    let path = programPath;\n    const reg = /(\\.[A-Za-z0-9]+|(\\[[0-9]+\\]))/ig;\n    let result;\n    while ((result = reg.exec(location)) !== null) {\n      let part = result[0];\n      if (part.startsWith('.')) {\n        part = part.replace('.', '');\n        path = path.get(part);\n      } else {\n        part = part.replace(/\\[|\\]/ig, '');\n        part = parseInt(part);\n        path = path[part];\n      }\n    }\n\n    return path;\n  }\n\n  pathLocationsToPathes(pathLocations) {\n    const paths = [];\n\n    this.sourceCode.traverseAsAST({\n      Program: path => {\n        pathLocations.forEach(location => {\n          paths.push(this.pathByLocationFromProgram(path, location));\n        });\n      }\n    });\n\n    return paths;\n  }\n\n  async getCorrespondingClasses(methodName) {\n    let index = await FileIndex.current();\n\n    //find classes that contain the method\n    let possibleClasses = await index.db.classes.filter(cl => {\n      return cl.methods.some(me => me.name == methodName);\n    }).toArray();\n\n    //find files that export things with the urls from the found classes\n    let possibleExports = await index.db.exports.where('url').anyOf(possibleClasses.map(cl => cl.url)).toArray();\n\n    //reduce the found classes with the found possible exports\n    let locations = possibleClasses.filter(cl => {\n      return possibleExports.some(e => e.url == cl.url && e.classes.some(eCl => eCl == cl.name));\n    });\n    return locations.filter(ea => ea.url.match(lively4url)); //filter local files\n  }\n\n  async getFunctionExportURLs(methodName) {\n    let index = await FileIndex.current();\n    let locations = await index.db.exports.filter(exp => {\n      return exp.functions.some(me => me == methodName);\n    }).toArray();\n    return locations.map(loc => loc.url).filter(url => url.match(lively4url));\n  }\n}\n\nObject.defineProperty(self, '__ASTCapabilities__', {\n  configurable: true,\n  enumerable: true,\n  get() {\n    return ASTCapabilities;\n  }\n});"]}