{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-bp2019/src/babylonian-programming-editor/utils/ast.js"],"names":["systemBabel","LocationConverter","DefaultDict","defaultBabylonConfig","maybeUnpackString","traverse","template","types","transform","transformFromAst","babel","deepCopy","obj","JSON","parse","stringify","e","console","warn","Object","assign","generateLocationMap","ast","_locationMap","keywords","enter","path","location","node","loc","keyword","type","end","line","start","column","length","astToKey","canBeProbe","isTrackableIdentifier","isIdentifier","isThisExpression","parentPath","isMemberExpression","parentKey","getFunctionParent","isTrackableParameter","params","includes","isTrackableMemberExpression","isTrackableReturnStatement","isReturnStatement","canBeSlider","isTrackableLoop","isLoop","canBeExample","functionParent","isFunctionName","get","name","isArrowFunctionName","canBeInstance","isClassName","isClassDeclaration","canBeReplacement","isVariableDeclarator","isAssignmentExpression","assignIds","_id","nextId","assignId","ID_COUNTER","applyBasicModifications","replacementUrls","wrapPropertyOfPath","property","oldBody","oldBodyNode","isBlockStatement","Array","newBodyNode","prepForInsert","blockStatement","maybeWrapInStatement","replaceWith","importNodes","BlockParent","isProgram","isSwitchStatement","body","IfStatement","SwitchCase","ImportDeclaration","isStringLiteral","_sourceUrl","push","Promise","all","map","importSource","source","value","importUrl","System","resolve","applyTracker","code","applyContext","context","prescriptNodes","astForCode","prescript","program","postscriptNodes","postscript","concat","collectImports","arr","i","applyReplacements","replacements","forEach","replacement","replacementNode","replacementNodeForValue","parent","init","applyProbes","annotations","trackedNodes","a","Identifier","insertIdentifierTracker","MemberExpression","ThisExpression","ReturnStatement","insertReturnTracker","BlockStatement","isFunction","insertIterationTracker","insertBlockTracker","insertTimer","Program","applyInstances","instances","customInstances","defaultInstanceNode","instance","className","instanceNode","id","CLASS","identifier","PARAMS","values","applyExamples","examples","functionCall","staticMethodCall","objectMethodCall","example","instanceId","parametersValuesNode","arrayExpression","parametersNames","parameterNamesForFunctionIdentifier","parametersNamessNode","s","nullLiteral","exampleCallNode","isClassMethod","classIdNode","findParent","p","static","ID","join","EXAMPLECALL","INSTANCE","trackerTemplate","trackerBuilder","numericLiteral","VALUE","NAME","stringLiteral","stringForPath","KEYWORD","statementParentPath","getStatementParent","functionParentPath","unshiftContainer","insertBefore","isBlockParent","unshift","isIfStatement","insertAfter","returnTracker","argument","blockId","tracker","iterationId","iterationCounter","isStart","parameterPaths","parameterPath","isAssignmentPattern","left","filter","constructorParameterNamesForClassIdentifier","functions","f","idPath","replacementNodeForCode","expression","right","error","wrapPrePostScript","args","mode","instanceTemplate","connectorTemplate","codeForAst","bodyForPath","assignLocationToBlockStatement","isStatement","isExpression","expressionNode","expressionStatement","isArrowFunctionExpression"],"mappings":"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","file":"ast.js","sourcesContent":["import systemBabel from 'systemjs-babel-build';\n\n//import { babel } from 'systemjs-babel-build';\nconst {\n  traverse,\n  template,\n  types,\n  transform,\n  transformFromAst\n} = systemBabel.babel;\nimport LocationConverter from \"./location-converter.js\";\nimport DefaultDict from \"./default-dict.js\";\nimport { defaultBabylonConfig } from \"./defaults.js\";\nimport { maybeUnpackString } from \"./utils.js\";\n\n/**\n * Creates a deep copy of arbitrary objects.\n * Does not copy functions!\n */\nexport function /*example:*//*example:*//*example:*/deepCopy/*{\"id\":\"71d1_e842_c8af\",\"name\":{\"mode\":\"input\",\"value\":\"HTML\"},\"color\":\"hsl(60, 30%, 70%)\",\"values\":{\"obj\":{\"mode\":\"select\",\"value\":\"9055_2982_7d26\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*//*{\"id\":\"f2b6_66ad_4a31\",\"name\":{\"mode\":\"input\",\"value\":\"Plain\"},\"color\":\"hsl(160, 30%, 70%)\",\"values\":{\"obj\":{\"mode\":\"input\",\"value\":\"{name: \\\"My name\\\"}\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*//*{\"id\":\"1db1_7cc0_11c6\",\"name\":{\"mode\":\"input\",\"value\":\"Recursive\"},\"color\":\"hsl(10, 30%, 70%)\",\"values\":{\"obj\":{\"mode\":\"select\",\"value\":\"1558_7aa2_37fa\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*/(obj) {\n  try {\n    /*probe:*/return/*{}*/ JSON.parse(JSON.stringify(obj));\n  } catch(e) {\n    console.warn(\"Could not deeply clone object\", obj);\n    /*probe:*/return/*{}*/ Object.assign({}, obj);\n  }\n}\n\n/**\n * Generates a locationMap for the AST\n */\nexport function /*example:*//*example:*//*example:*/generateLocationMap/*{\"id\":\"c328_5d11_5168\",\"name\":{\"mode\":\"input\",\"value\":\"Not an AST\"},\"color\":\"hsl(180, 30%, 70%)\",\"values\":{\"ast\":{\"mode\":\"select\",\"value\":\"9055_2982_7d26\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*//*{\"id\":\"4ebc_b290_28de\",\"name\":{\"mode\":\"input\",\"value\":\"Fibonacci\"},\"color\":\"hsl(10, 30%, 70%)\",\"values\":{\"ast\":{\"mode\":\"select\",\"value\":\"8a96_17d6_1be7\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*//*{\"id\":\"345b_37c4_c8b1\",\"name\":{\"mode\":\"input\",\"value\":\"Simple\"},\"color\":\"hsl(300, 30%, 70%)\",\"values\":{\"ast\":{\"mode\":\"select\",\"value\":\"35d8_cf9d_8ad4\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*/(ast) {\n  ast._locationMap = new DefaultDict(Object);\n\n  const keywords = {\n    \"ForStatement\": \"for\",\n    \"ForInStatement\": \"for\",\n    \"ForOfStatement\": \"for\",\n    \"WhileStatement\": \"while\",\n    \"DoWhileStatement\": \"do\",\n    \"ReturnStatement\": \"return\"\n  };\n\n  traverse(ast, {\n    enter(path) {\n      let location = path.node.loc;\n      if(!location) {\n        return;\n      }\n\n      // Some Nodes are only associated with their keywords\n      const keyword = keywords[path.type];\n      if(keyword) {\n        location.end.line = location.start.line;\n        location.end.column = location.start.column + keyword.length;\n      }\n\n      ast._locationMap[LocationConverter.astToKey(location)] = path;\n    }\n  });\n}\n\n/**\n * Checks whether a path can be probed\n */\nexport function /*example:*//*example:*/canBeProbe/*{\"id\":\"ced4_825a_793a\",\"name\":{\"mode\":\"input\",\"value\":\"Member Identifier\"},\"color\":\"hsl(330, 30%, 70%)\",\"values\":{\"path\":{\"mode\":\"select\",\"value\":\"d779_a710_b464\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*//*{\"id\":\"6104_8577_2ac3\",\"name\":{\"mode\":\"input\",\"value\":\"Identifier\"},\"color\":\"hsl(190, 30%, 70%)\",\"values\":{\"path\":{\"mode\":\"select\",\"value\":\"1558_7aa2_37fa\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*/(path) {\n  if(!path) {\n    return false;\n  }\n  \n  const /*probe:*/isTrackableIdentifier/*{}*/ = (path.isIdentifier() || path.isThisExpression())\n                                 && (!path.parentPath.isMemberExpression()\n                                     || path.parentKey === \"object\")\n                                 && (path.parentPath !== path.getFunctionParent());\n  const isTrackableParameter = path.getFunctionParent().node.params \n                               && (path.parentPath === path.getFunctionParent())\n                               && (path.getFunctionParent().node.params.includes(path.node));\n  const /*probe:*/isTrackableMemberExpression/*{}*/ = path.isMemberExpression();\n  const /*probe:*/isTrackableReturnStatement/*{}*/ = path.isReturnStatement();\n  /*probe:*/return/*{}*/ isTrackableIdentifier\n         || isTrackableParameter\n         || isTrackableMemberExpression\n         || isTrackableReturnStatement;\n}\n\n/**\n * Checks whether a path can be a slider\n */\nexport function /*example:*/canBeSlider/*{\"id\":\"4426_b3f0_d927\",\"name\":{\"mode\":\"input\",\"value\":\"Function Name\"},\"color\":\"hsl(130, 30%, 70%)\",\"values\":{\"path\":{\"mode\":\"select\",\"value\":\"d695_3c6c_89a9\"}},\"instanceId\":{\"mode\":\"input\",\"value\":\"\"},\"prescript\":\"\",\"postscript\":\"\"}*/(path) {\n  if(!path) {\n    return false;\n  }\n  \n  const isTrackableIdentifier = path.isIdentifier()\n                                && path.parentPath === path.getFunctionParent();\n  const isTrackableLoop = path.isLoop();\n  return /*probe:*/isTrackableIdentifier/*{}*/ || /*probe:*/isTrackableLoop/*{}*/;\n}\n\n/**\n * Checks whether a path can be an example\n */\nexport const canBeExample = (path) => {\n  if(!path || !path.getFunctionParent) {\n    return false;\n  }\n  \n  // We have to be the name of a function\n  const functionParent = path.getFunctionParent();\n  const isFunctionName = (functionParent\n                          && (functionParent.get(\"id\") === path\n                              || functionParent.get(\"key\") === path));\n  return (isFunctionName && path.node.name !== \"constructor\")\n         || isArrowFunctionName(path);\n}\n\n/**\n * Checks whether a path can be an instance\n */\nexport const canBeInstance  = (path) => {\n  if(!path) {\n    return false;\n  }\n  \n  // We have to be the name of a class\n  const isClassName = (path.parentPath.isClassDeclaration() && path.parentKey === \"id\");\n  return isClassName;\n}\n\n/**\n * Checks whether a path can be replaced\n */\nexport const canBeReplacement = (path) => {\n  if(!path) {\n    return false;\n  }\n  \n  // We have to be the righthand side of an assignment\n  return ((path.parentPath.isVariableDeclarator() && path.parentKey === \"init\")\n          || (path.parentPath.isAssignmentExpression() && path.parentKey === \"right\"));\n}\n\n/**\n * Assigns IDs to add nodes of the AST\n */\nexport const assignIds = (ast) => {\n  traverse(ast, {\n    enter(path) {\n      path.node._id = nextId();\n    }\n  });\n  return ast;\n};\nconst assignId = (node) => {\n  node._id = nextId();\n  return node;\n}\nlet ID_COUNTER = 1;\nconst nextId = () => ID_COUNTER++;\n\n/**\n * Applies basic modifications to the given AST\n */\nexport const applyBasicModifications = async (ast, replacementUrls = {}) => {\n  const wrapPropertyOfPath = (path, property) => {\n    const oldBody = path.get(property);\n    const oldBodyNode = path.node[property];\n    if(!oldBodyNode) {\n      return;\n    }\n    if(oldBody.isBlockStatement && oldBody.isBlockStatement()) {\n      // This is already a block\n      return;\n    } else if(oldBody instanceof Array) {\n      const newBodyNode = prepForInsert(types.blockStatement(oldBodyNode));\n      path.node[property] = [newBodyNode];\n    } else {\n      const newBodyNode = prepForInsert(types.blockStatement([maybeWrapInStatement(oldBodyNode)]));\n      oldBody.replaceWith(newBodyNode);\n    }\n    return path;\n  }\n\n  // Prepare Tracker, enforce that all bodies are in BlockStatements, and collect imports\n  const importNodes = [];\n  traverse(ast, {\n    BlockParent(path) {\n      if(path.isProgram() || path.isBlockStatement() || path.isSwitchStatement()) {\n        return;\n      }\n      if(!path.node.body) {\n        console.warn(\"A BlockParent without body: \", path);\n      }\n\n      wrapPropertyOfPath(path, \"body\");\n    },\n    IfStatement(path) {\n      for(let property of [\"consequent\", \"alternate\"]) {\n        wrapPropertyOfPath(path, property);\n      }\n    },\n    SwitchCase(path) {\n      wrapPropertyOfPath(path, \"consequent\");\n    },\n    ImportDeclaration(path) {\n      if(path.get(\"source\").isStringLiteral() && ast._sourceUrl && ast._sourceUrl.length) {\n        importNodes.push(path.node);\n      }\n    }\n  });\n\n  await Promise.all(importNodes.map(async (node) => {\n    // Turn imports into absolute URLs so they work in the temporary workspace\n    const importSource = node.source.value;\n    const importUrl = await System.resolve(importSource, ast._sourceUrl);\n\n    // Set either the real or the replacement URL\n    if(replacementUrls[importUrl]) {\n      node.source.value = replacementUrls[importUrl];\n    } else {\n      node.source.value = importUrl;\n    }\n  }));\n}\n\nexport const applyTracker = (code) =>\n  `const __connections = this.connections;\nconst __tracker = this.tracker;\n${code};\n__tracker.timer.reset();`;\n\nexport const applyContext = async (ast, context, replacementUrls) => {\n  const prescriptNodes = astForCode(context.prescript).program.body;\n  const postscriptNodes = astForCode(context.postscript).program.body;\n  \n  ast.program.body = prescriptNodes.concat(ast.program.body).concat(postscriptNodes);\n  \n  // Fix imports\n  const importNodes = [];\n  const collectImports = arr => {\n    for(let i = 0; i < arr.length && arr[i].type === \"ImportDeclaration\"; i++) {\n      importNodes.push(arr[i]);\n    }\n  };\n  collectImports(prescriptNodes);\n  collectImports(postscriptNodes);\n\n  await Promise.all(importNodes.map(async (node) => {\n    // Turn imports into absolute URLs so they work in the temporary workspace\n    const importSource = node.source.value;\n    const importUrl = await System.resolve(importSource, ast._sourceUrl);\n\n    // Set either the real or the replacement URL\n    if(replacementUrls[importUrl]) {\n      node.source.value = replacementUrls[importUrl];\n    } else {\n      node.source.value = importUrl;\n    }\n  }));\n  \n  return ast;\n}\n\n/**\n * Applies replacement markers to the given AST\n */\nexport const applyReplacements = (ast, replacements) => {\n  replacements.forEach((replacement) => {\n    const replacementNode = replacementNodeForValue(replacement.value);\n    if(!replacementNode) {\n      return;\n    }\n    const path = ast._locationMap[replacement.location];\n    if(path.parentPath.isVariableDeclarator()) {\n      path.parent.init = replacementNode;\n    } else {\n      path.replaceWith(replacementNode);\n    }\n  });\n};\n\n/**\n * Applies probe markers to the given AST\n */\nexport const applyProbes = (ast, annotations) => {\n  const trackedNodes = annotations.map((a) => ast._locationMap[a.location].node);\n\n  traverse(ast, {\n    Identifier(path) {\n      if(!trackedNodes.includes(path.node)) return;\n      insertIdentifierTracker(path);\n    },\n    MemberExpression(path) {\n      if(!trackedNodes.includes(path.node)) return;\n      insertIdentifierTracker(path);\n    },\n    ThisExpression(path) {\n      if(!trackedNodes.includes(path.node)) return;\n      insertIdentifierTracker(path);\n    },\n    ReturnStatement(path) {\n      if(!trackedNodes.includes(path.node)) return;\n      insertReturnTracker(path);\n    },\n    BlockStatement(path) {\n      if(path.parentPath.isFunction() || path.parentPath.isLoop()) {\n        insertIterationTracker(path, true);\n      }\n      insertBlockTracker(path);\n      insertTimer(path);\n    },\n    Program(path) {\n      insertIterationTracker(path, false);\n      insertBlockTracker(path);\n      insertTimer(path, true);\n    }\n  });\n};\n\n/**\n * Generates instances for the given AST\n */\nexport const applyInstances = (ast, instances, customInstances) => {\n  const defaultInstanceNode = template(`const __0 = () => null;`)();\n  ast.program.body.push(defaultInstanceNode);\n\n  instances.forEach((instance) => {\n    const path = ast._locationMap[instance.location];\n    const className = path.node.name;\n\n    let instanceNode = template(`const __${instance.id} = () => new CLASS(PARAMS);`)({\n      CLASS: types.identifier(className),\n      PARAMS: instance.values.map(replacementNodeForValue)\n    });\n\n    if(instanceNode) {\n      ast.program.body.push(instanceNode);\n    }\n  });\n\n  customInstances.forEach((instance) => {\n    let instanceNode = template(`const __${instance.id} = () => { ${instance.code} }`)();\n\n    if(instanceNode) {\n      ast.program.body.push(instanceNode);\n    }\n  });\n}\n\n/**\n * Applies example markers to the given AST\n */\nexport const applyExamples = (ast, examples) => {\n  // Prepare templates to insert\n  const functionCall = template(\"ID.apply(this, PARAMS)\");\n  const staticMethodCall = template(\"CLASS.ID.apply(this, PARAMS)\");\n  const objectMethodCall = template(\"CLASS.prototype.ID.apply(this, PARAMS)\");\n\n  // Apply the markers\n  examples.forEach((example) => {\n    const path = ast._locationMap[example.location];\n    let instanceNode = replacementNodeForValue(example.instanceId);\n    let parametersValuesNode = types.arrayExpression(\n      example.values.map(replacementNodeForValue)\n    );\n    let parametersNames = parameterNamesForFunctionIdentifier(path);\n    let parametersNamessNode = types.arrayExpression(\n      parametersNames.map((s) => types.identifier(s))\n    );\n\n    if(!parametersValuesNode) {\n      parametersValuesNode = types.nullLiteral();\n    }\n\n    const functionParent = path.getFunctionParent()\n    let exampleCallNode;\n\n    // Distinguish between Methods and Functions\n    if(functionParent.isClassMethod()) {\n      // We have a method\n      const classIdNode = functionParent.findParent(p => p.type === \"ClassDeclaration\").get(\"id\").node;\n\n      // Distinguish between static and object methods\n      if(functionParent.node.static) {\n        exampleCallNode = staticMethodCall({\n          CLASS: types.identifier(classIdNode.name),\n          ID: types.identifier(path.node.name),\n          PARAMS: parametersNamessNode\n        });\n      } else {\n        // Get the example instance\n        exampleCallNode = objectMethodCall({\n          CLASS: types.identifier(classIdNode.name),\n          ID: types.identifier(path.node.name),\n          PARAMS: parametersNamessNode\n        });\n      }\n    } else {\n      exampleCallNode = functionCall({\n        ID: types.identifier(path.node.name),\n        PARAMS: parametersNamessNode\n      });\n    }\n\n    // Insert a call at the end of the script\n    if(exampleCallNode) {\n      ast.program.body.push(\n        template(`\n          try {\n            __tracker.example(\"${example.id}\");\n            const example = function(${parametersNames.join(\", \")}) {\n              ${example.prescript};\n              EXAMPLECALL;\n              ${example.postscript};\n            };\n            example.apply(INSTANCE, PARAMS);\n          } catch(e) {\n            __tracker.error(e.message);\n          }`)({\n          EXAMPLECALL: exampleCallNode,\n          INSTANCE: instanceNode,\n          PARAMS: parametersValuesNode\n        })\n      );\n    }\n  });\n}\n\n/**\n * Insers an appropriate tracker for the given identifier path\n */\nconst insertIdentifierTracker = (path) => {\n  // Prepare Trackers\n  const trackerTemplate = template(\"__tracker.id(ID, __tracker.exampleId, __iterationId, __iterationCount, VALUE, NAME, KEYWORD)\");\n  const trackerBuilder = (keyword = \"after\") => trackerTemplate({\n    ID:      types.numericLiteral(path.node._id),\n    VALUE:   deepCopy(path.node),\n    NAME:    types.stringLiteral(stringForPath(path)),\n    KEYWORD: types.stringLiteral(keyword),\n  });\n\n  // Find the closest parent statement\n  let statementParentPath = path.getStatementParent();\n\n  // We have to insert the tracker at different positions depending on\n  // the context of the tracked Identifier\n  // TODO: Handle switch\n  if(path.parentKey === \"params\") {\n    // We are in a parameter list\n    // Prepend tracker to body of function\n    const functionParentPath = path.getFunctionParent();\n    functionParentPath.get(\"body\").unshiftContainer(\"body\", trackerBuilder());\n  } else if(statementParentPath.isReturnStatement()) {\n    // We are in a return statement\n    // Prepend the tracker to the return\n    statementParentPath.insertBefore(trackerBuilder());\n  } else if(statementParentPath.isBlockParent()) {\n    // We are in a block\n    // Insert into the block body\n    const body = statementParentPath.get(\"body\");\n    if(body instanceof Array) {\n      body.unshift(trackerBuilder());\n    } else if (body.isBlockStatement()) {\n      body.unshiftContainer(\"body\", trackerBuilder());\n    } else {\n      body.replaceWith(\n        types.blockStatement([\n          body\n        ])\n      );\n      body.unshiftContainer(\"body\", trackerBuilder());\n    }\n  } else if(statementParentPath.isIfStatement()) {\n    // We are in an if\n    // We have to insert the tracker before the if\n    statementParentPath.insertBefore(trackerBuilder());\n  } else if(path.parentPath.isVariableDeclarator()\n            && path.parentKey === \"id\") {\n    // Declaration - only track value after\n    statementParentPath.insertAfter(trackerBuilder());\n  } else {\n    // Normal statement - track value before and after\n    statementParentPath.insertBefore(trackerBuilder(\"before\"));\n    statementParentPath.insertAfter(trackerBuilder(\"after\"));\n  }\n};\n\n/**\n * Insers an appropriate tracker for the given return statement\n */\nconst insertReturnTracker = (path) => {\nconst returnTracker = template(\"__tracker.id(ID, __tracker.exampleId, __iterationId, __iterationCount, VALUE, NAME)\")({\n    ID: types.numericLiteral(path.node._id),\n    VALUE: path.node.argument,\n    NAME: types.stringLiteral(\"return\")\n  });\n  path.get(\"argument\").replaceWith(returnTracker);\n}\n\n/**\n * Inserts a tracker to check whether a block was entered\n */\nconst insertBlockTracker = (path) => {\n  if(typeof path.node._id === \"undefined\") {\n    return;\n  }\n  const blockId = template(\"const __blockId = ID\")({\n    ID: types.numericLiteral(path.node._id)\n  });\n  const tracker = template(\"__tracker.block(__blockId)\")();\n  path.unshiftContainer(\"body\", tracker);\n  path.unshiftContainer(\"body\", blockId);\n};\n\n/**\n * Inserts a tracker to count iterations\n */\nconst insertIterationTracker = (path) => {\n  if(typeof path.node._id === \"undefined\") {\n    return;\n  }\n  \n  const iterationId = template(\"const __iterationId = ID\")({\n    ID: types.numericLiteral(path.node._id)\n  });\n  const iterationCounter = template(\"const __iterationCount = __tracker.iteration(__iterationId)\")();\n  \n  path.unshiftContainer(\"body\", iterationCounter);\n  path.unshiftContainer(\"body\", iterationId);\n};\n\n\n/**\n * Inserts a timer check\n */\nconst insertTimer = (path, isStart = false) => {\n  if(typeof path.node._id === \"undefined\") {\n    return;\n  }\n  const code = `__tracker.timer.${isStart ? \"start\" : \"check\"}()`;\n  path.unshiftContainer(\"body\", template(code)());\n};\n\n/**\n * Returns a list of parameter names for the given function Identifier\n */\nexport const parameterNamesForFunctionIdentifier = (path) => {\n  let parameterPaths = [];\n  if(isArrowFunctionName(path)) {\n    parameterPaths = path.parentPath.get(\"init\").get(\"params\");\n  } else {\n    parameterPaths = path.getFunctionParent().get(\"params\");\n  }\n\n  return parameterPaths.map(parameterPath => {\n    if(parameterPath.isIdentifier()) {\n      return parameterPath.node.name;\n    } else if(parameterPath.isAssignmentPattern()) {\n      return parameterPath.node.left.name;\n    }\n    return null;\n  }).filter(name => !!name);\n}\n\n/**\n * Returns a list of parameter names for the constructor of given class Identifier\n */\nexport const constructorParameterNamesForClassIdentifier = (path) => {\n  const functions = path.parentPath.get(\"body\").get(\"body\");\n  for(let f of functions) {\n    let idPath = f.get(\"key\");\n    if(idPath.node.name === \"constructor\") {\n      return parameterNamesForFunctionIdentifier(idPath);\n    }\n  }\n  return [];\n}\n\n/**\n * Generates a replacement node\n * (to be used as the righthand side of an assignment)\n */\nexport const replacementNodeForCode = (code) => {\n  // The code we get here will be used as the righthand side of an Assignment\n  // We we pretend that it is that while parsing\n\n  if(!code || !code.length) {\n    return types.nullLiteral();\n  }\n\n  code = `placeholder = ${code}`;\n  try {\n    const ast = astForCode(code);\n    return ast.program.body[0].expression.right;\n  } catch (e) {\n    console.error(\"Error parsing replacement node\", e);\n    return null;\n  }\n}\n\nconst wrapPrePostScript = (name, args, code) => {\n  code = `const ${name} = function(${args.join(\", \")}) { ${code} };`;\n  try {\n    const ast = astForCode(code);\n    return ast.program.body[0];\n  } catch (e) {\n    console.error(\"Error parsing replacement node\", e);\n    return null;\n  }\n}\n\nconst replacementNodeForValue = (value) => {\n    switch(value.mode) {\n      case \"input\":\n        return replacementNodeForCode(value.value);\n      case \"select\":\n        return replacementNodeForCode(instanceTemplate(value.value));\n      case \"connect\":\n        return replacementNodeForCode(connectorTemplate(value.value));\n    }\n  };\n\n/**\n * Parses code and returns the AST\n */\nexport const astForCode = (code) =>\n  transform(code, Object.assign({}, defaultBabylonConfig(), {\n    code: false,\n    ast: true\n  })).ast\n\n/**\n * Generates executable code for a given AST\n */\nexport const codeForAst = (ast) =>\n  transformFromAst(ast, Object.assign({}, defaultBabylonConfig(), {\n    code: true,\n    ast: false\n  })).code;\n\n\nconst stringForPath = (path) => {\n  if(path.isIdentifier()) {\n    return path.node.name;\n  } else if(path.isThisExpression()) {\n    return \"this\";\n  } else if(path.isMemberExpression()) {\n    return `${stringForPath(path.get(\"object\"))}.${stringForPath(path.get(\"property\"))}`;\n  } else {\n    return \"\";\n  }\n}\n\nexport const bodyForPath = (path) => {\n  if(path.node && path.node.body) {\n    return path.get(\"body\");\n  } else if(path.parentPath && path.parentPath.node && path.parentPath.node.body) {\n    return path.parentPath.get(\"body\");\n  }\n  return null;\n}\n\nconst assignLocationToBlockStatement = (node) => {\n  if(node.body.length) {\n    node.loc = {\n      start: node.body[0].loc.start,\n      end: node.body[node.body.length - 1].loc.end\n    }\n  } else {\n    node.loc = {\n      start: { line: 1, column: 0 },\n      end: { line: 1, column: 0 }\n    };\n  }\n  return node;\n}\n\nconst prepForInsert = (node) => {\n  assignId(node);\n  if(node.type === \"BlockStatement\") {\n    assignLocationToBlockStatement(node);\n  }\n  return node;\n}\n\nconst maybeWrapInStatement = (node) => {\n  if(types.isStatement(node)) {\n    return node;\n  } else if(types.isExpression(node)) {\n    const expressionNode = types.expressionStatement(node);\n    expressionNode.loc = node.loc;\n    return expressionNode;\n  } else {\n    console.error(\"Tried to wrap something unknown:\", node);\n    return node;\n  }\n}\n\nconst connectorTemplate = (id) => `__connections[\"${id}\"]`;\n\nconst instanceTemplate = (id) => `__${id}()`;\n\nconst isArrowFunctionName = path =>\n  (path.isIdentifier()\n   && path.parentPath.isVariableDeclarator()\n   && path.parentPath.get(\"id\") === path\n   && path.parentPath.get(\"init\").isArrowFunctionExpression());\n\n\n/* Context: {\"context\":{\"prescript\":\"\",\"postscript\":\"\"},\"customInstances\":[{\"id\":\"35d8_cf9d_8ad4\",\"name\":\"Simple AST\",\"code\":\"return transform(\\\"const i = 0\\\").ast;\"},{\"id\":\"9055_2982_7d26\",\"name\":\"<div>\",\"code\":\"return document.createElement(\\\"div\\\");\"},{\"id\":\"8a96_17d6_1be7\",\"name\":\"Fibonacci AST\",\"code\":\"const code = `\\nfunction fib(i) {\\n  if(i <= 1) return 1;\\n  return fib(i-1) + fib(i-2);\\n}`\\n\\nreturn transform(code).ast;\"},{\"id\":\"1558_7aa2_37fa\",\"name\":\"Identifier Path\",\"code\":\"const ast = transform(\\\"const i = 0\\\").ast;\\nlet id = null;\\ntraverse(ast, {\\n  Identifier(path) {\\n    id = path;\\n  } \\n})\\nreturn id;\"},{\"id\":\"d779_a710_b464\",\"name\":\"Member Identifier Path\",\"code\":\"const ast = transform(\\\"this.test = 0\\\").ast;\\nlet id = null;\\ntraverse(ast, {\\n  Identifier(path) {\\n    id = path;\\n  } \\n})\\nreturn id;\"},{\"id\":\"d695_3c6c_89a9\",\"name\":\"Function Name Path\",\"code\":\"const ast = transform(\\\"function test() {}\\\").ast;\\nlet id = null;\\ntraverse(ast, {\\n  Identifier(path) {\\n    id = path;\\n  } \\n})\\nreturn id;\"}]} */"]}