{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-tom/src/components/demo/lively-whyline-tracing.js"],"names":["systemBabel","types","t","template","traverse","babel","ExecutionTrace","constructor","astRootNode","astRoot","nodeMap","node_map","traceRoot","newTraceNode","traceid","parentNode","previousNode","lastOccurrenceMap","order","astNodeId","astNode","traceNodeType","addOccurrence","id","traceNode","last","previousOccurrence","nextOccurrence","begin","addChild","val","value","end","exp","asgn","argFunc","setVariableValues","decl","args","declarator","descendantWithId","func","rtrn","parent","isFunction","iter","stmt","TraceNode","children","setPredecessor","previous","predecessor","successor","preceedsChildren","child","push","values","variableValues","assignmentTargets","map","node","i","isIdentifier","object","property","computed","name","traceId","functionParent","findParent","findDescendant","successorWithId","findSuccessor","predecessorWithId","findPredecessor","parentWithId","tester","parents","length","shift","find","branchesControlFlow","previousControlFlow","isBefore","other","isAfter","previousAssignmentTo","identifier","pred","assigns","variablesOfInterest","variables","Set","collectVariablesOfInterest","delete","collectAssignmentTargets","forEach","add","scope","variableNamed","readsVariable","writesVariable","_scope","getScope","isScope","mapToNodeType","nodeTypes","VariableExpressionNode","LiteralExpressionNode","BinaryExpressionNode","UnaryExpressionNode","UpdateExpressionNode","ObjectExpressionNode","ArrayExpressionNode","AssignmentExpressionNode","CallExpressionNode","MemberExpressionNode","DeclaratorNode","ReturnNode","NewExpressionNode","ConditionalExpressionNode","ExpressionNode","WhileStatementNode","DoWhileStatementNode","IfStatementNode","VariableDeclarationNode","ProgramNode","ForStatementNode","BlockNode","FunctionNode","nodeType","mapsTo","astTypes","some","astType","isType","type","toDisplayString","maxLength","Array","isArray","str","toString","substr","labelString","reconstructMemberExpression","valueString","assignmentsString","assignments","left","index","join","right","op","operator","argument","function","numArgs","functionIsTraced","arguments","slice","lastChild","call","argString","expNode","test","hasArgument","consequences","kind","reduce","vars","concat","variable","log","init","declaration","declareVariable","equalIdentifiers","identifiers","filter","ScopeNode","sourceNode","Variable","source","history","indexBefore","indexAfter","findBefore","findAfter","writeBefore","writeAfter","readBefore","readAfter","readOrWriteBefore","readOrWriteAfter","identifier1","identifier2","assertIdentifier","scopeId","window","lively4ExecutionTrace"],"mappings":"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","file":"lively-whyline-tracing.js","sourcesContent":["import systemBabel from 'systemjs-babel-build';\nconst { types: t, template, traverse } = systemBabel.babel;\n\nexport class ExecutionTrace {\n  constructor(astRootNode){\n    this.astRoot = astRootNode;\n    this.nodeMap = astRootNode.node_map;\n    this.traceRoot = this.newTraceNode(astRootNode.traceid);\n    this.parentNode = this.traceRoot;\n    this.previousNode = this.traceRoot;\n    this.lastOccurrenceMap = [];\n    this.traceRoot.order = 0;\n  }\n  \n  newTraceNode(astNodeId) {\n    let astNode = this.nodeMap[astNodeId];\n    return new astNode.traceNodeType(astNode);\n  }\n  \n  addOccurrence(id, traceNode) {\n    const last = this.lastOccurrenceMap[id];\n    if (last) {\n      traceNode.previousOccurrence = last;\n      last.nextOccurrence = traceNode;\n    }\n    this.lastOccurrenceMap[id] = traceNode;\n  }\n  \n  begin(id) {\n    const traceNode = this.newTraceNode(id);\n    this.parentNode.addChild(traceNode);\n    this.previousNode = traceNode.begin(this.previousNode);\n    this.addOccurrence(id, traceNode);\n    return this.parentNode = traceNode;\n  }\n  \n  /*\n   * Externally visible tracing functions\n   */\n  \n  val(id, value) {\n    const traceNode = this.begin(id);\n    this.end(traceNode);\n    return traceNode.value = value;\n  }\n  \n  exp(id, exp) {\n    const traceNode = this.begin(id);\n    const value = traceNode.value = exp();\n    this.end(traceNode);\n    return value;\n  }\n  \n  asgn(id, exp, argFunc) {\n    const traceNode = this.begin(id);\n    const value = traceNode.value = exp();\n    traceNode.setVariableValues(argFunc());\n    this.end(traceNode);\n    return value;\n  }\n  \n  decl(id, args) {\n    const declarator = this.parentNode.descendantWithId(id);\n    declarator.setVariableValues(args);\n  }\n  \n  func(id, args) {\n    const traceNode = this.begin(id);\n    traceNode.setVariableValues(args);\n  }\n  \n  rtrn(id, exp) {\n    const traceNode = this.begin(id);\n    const value = traceNode.value = exp();\n    let parent = traceNode;\n    while (!parent.isFunction) {\n      this.end(parent);\n      parent = parent.parent;\n    }\n    this.end(parent);\n    return parent.value = value;\n  }\n  \n  iter() {\n    \n  }\n  \n  stmt(id) {\n    this.begin(id);\n  }\n  \n  end(traceNode = this.parentNode) {\n    this.previousNode = traceNode.end(this.previousNode);\n    this.parentNode = traceNode.parent;\n  }\n}\n\nexport class TraceNode {\n  constructor(astNode){\n    this.children = [];\n    this.astNode = astNode;\n  }\n  \n  /*\n   * Tracing\n   */\n  \n  setPredecessor(previous) {\n    this.predecessor = previous;\n    previous.successor = this;\n    this.order = previous.order + 1;\n  }\n  \n  begin(previous) {\n    if (this.preceedsChildren){\n      this.setPredecessor(previous);\n      return this;\n    } else {\n      return previous;\n    }\n  }\n  \n  end(previous) {\n    if (this.preceedsChildren){\n      return previous;\n    } else {\n      this.setPredecessor(previous);\n      return this;\n    }\n  }\n  \n  addChild(child) {\n    child.parent = this;\n    this.children.push(child);\n  }\n  \n  setVariableValues(values) {\n    this.variableValues = this.assignmentTargets.map((node, i) => {\n      if (t.isIdentifier(node)) {\n        return values[i];\n      } else { //node is MemberExpression\n        const object = this.descendantWithId(node.object.traceid).value;\n        const property = node.computed ? this.descendantWithId(node.property.traceid).value : node.property.name;\n        return object[property];\n      }\n    });\n  }\n  \n  get traceId() { return this.astNode.traceid }\n  get assignmentTargets() { return this.astNode.assignmentTargets }\n  \n  /*\n   * Tree Navigation\n   */\n  \n  functionParent() {\n    return this.findParent((node) => node.isFunction);\n  }\n  \n  descendantWithId(traceId) {\n    return this.findDescendant((node) => node.traceId == traceId);\n  }\n  \n  successorWithId(traceId) {\n    return this.findSuccessor((node) => node.traceId == traceId);\n  }\n  \n  predecessorWithId(traceId) {\n    return this.findPredecessor((node) => node.traceId == traceId);\n  }\n  \n  parentWithId(traceId) {\n    return this.findParent((node) => node.traceId == traceId);\n  }\n  \n  findDescendant(tester) {\n    //find (BFS) a descendant for which `tester` evaluates to true\n    //returns `null` if no such node was found\n    const parents = [this];\n    while (parents.length > 0) {\n      const children = parents.shift().children;\n      const child = children.find(tester);\n      if (child) return child;\n      parents.push(...children);\n    }\n    return null;\n  }\n  \n  findSuccessor(tester) {\n    //find first successor for which `tester` evaluates to true\n    //returns `null` if no such node was found\n    let node = this;\n    do {\n      node = node.successor;\n    } while (node && !tester(node));\n    return node || null;\n  }\n  \n  findPredecessor(tester) {\n    //find first predecessor for which `tester` evaluates to true\n    //returns `null` if no such node was found\n    let node = this;\n    do {\n      node = node.predecessor;\n    } while (node && !tester(node));\n    return node || null;\n  }\n  \n  findParent(tester) {\n    //find first parent for which `tester` evaluates to true\n    //returns `null` if no such node was found\n    let node = this;\n    do {\n      node = node.parent;\n    } while (node && !tester(node));\n    return node || null;\n  }\n  \n  get preceedsChildren() { return true }\n  \n  /*\n   * Control Flow\n   */\n  \n  get branchesControlFlow() { return false }\n  \n  previousControlFlow(){\n    return this.findParent((parent) => {\n      return parent.branchesControlFlow;\n    });\n  }\n  \n  isBefore(other) {\n    return this.order < other.order\n  }\n  \n  isAfter(other) {\n    return this.order > other.order\n  }\n  \n  /*\n   * Data Flow\n   */\n    \n  previousAssignmentTo(identifier) {\n    return this.findPredecessor((pred) => {\n      return pred.assigns(identifier);\n    });\n  }\n  \n  variablesOfInterest() {\n    const variables = new Set;\n    this.collectVariablesOfInterest(variables);\n    variables.delete(null);\n    return [...variables];\n  }\n  \n  collectVariablesOfInterest(variables) { }\n  \n  collectAssignmentTargets(variables) {\n    this.assignmentTargets.forEach((id) => {\n      variables.add(this.scope.variableNamed(id));\n    })\n  }\n  \n  assigns(identifier) {\n    return false;\n  }\n  \n  get readsVariable() { return false }\n  get writesVariable() { return false }\n  \n  get scope() {\n    return this._scope || (this._scope = this.getScope());\n  }\n  \n  getScope() {\n    return this.findParent((node) => node.isScope);\n  }\n  \n  /*\n   * Sub-Types\n   */\n  \n  static mapToNodeType(astNode) {\n    let nodeTypes = [\n      VariableExpressionNode,\n      LiteralExpressionNode, //group\n      \n      BinaryExpressionNode,\n      UnaryExpressionNode,\n      UpdateExpressionNode,\n      ObjectExpressionNode,\n      ArrayExpressionNode,\n      AssignmentExpressionNode,\n      CallExpressionNode,\n      MemberExpressionNode,\n      DeclaratorNode,\n      ReturnNode,\n      NewExpressionNode,\n      ConditionalExpressionNode,\n      ExpressionNode, //group\n      \n      WhileStatementNode,\n      DoWhileStatementNode,\n      \n      IfStatementNode,\n      VariableDeclarationNode,\n      \n      ProgramNode,\n      ForStatementNode,\n      BlockNode,\n      FunctionNode //group\n    ];\n    let nodeType = nodeTypes.find((nodeType) => {\n      return nodeType.mapsTo(astNode)\n    });\n    if (!nodeType) nodeType = this;\n    return nodeType\n  }\n  \n  static get astTypes() { return [] }\n  \n  static mapsTo(astNode) {\n    return this.astTypes.some((astType) => {\n      return t.isType(astNode.type, astType);\n    })\n  }\n  \n  get isFunction() { return false }\n  get isScope() { return false }\n  \n  /*\n   * Display\n   */\n  \n  toDisplayString(value, maxLength = 10) {\n    if (value === null) return 'null';\n    if (Array.isArray(value)) {\n      let str = value.toString();\n      if (str.length > maxLength) {\n        str = str.substr(0, maxLength+2) + \"...\";\n      }\n      return `[${str}]`;\n    }\n    let str = '';\n    let type = typeof(value);\n    switch(type) {\n      case 'undefined':\n        return 'undefined';\n      \n      case 'object':\n        return '{...}';\n        \n      case 'boolean':\n        return value.toString();\n        \n      case 'function':\n        return value.name || 'fn';\n        \n      case 'number':\n        return value.toString();\n        \n      case 'string':\n        str = value.substr(0, maxLength);\n        if (value.length > maxLength) str += '...';\n        str = `\"${str}\"`;\n        return str;\n    }    \n    return value.toString();\n  }\n  \n  labelString() {\n    return this.astNode.type;\n  }\n  \n  reconstructMemberExpression(astNode) {\n    const object = this.descendantWithId(astNode.object.traceid).valueString();\n    if (astNode.computed) {\n      const property = this.descendantWithId(astNode.property.traceid).valueString();\n      return `${object}[${property}]`;\n    } else {\n      const property = astNode.property.name;\n      return `${object}.${property}`\n    }\n  }\n  \n  assignmentsString() {\n    const assignments = this.assignmentTargets.map((left, index) => {\n      const name = t.isIdentifier(left)\n                    ? left.name\n                    : this.reconstructMemberExpression(left);\n      const value = this.toDisplayString(this.variableValues[index]);\n      return `${name} = ${value}`;\n    });\n    return assignments.join(\", \");\n  }\n}\n\nclass ExpressionNode extends TraceNode {\n  static get astTypes() { return ['Expression'] }\n  \n  get preceedsChildren() { return false }\n  \n  valueString() {\n    return this.toDisplayString(this.value);\n  }\n  \n  labelString() {\n    return '';\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.children.forEach((node) => node.collectVariablesOfInterest(variables));\n  }\n}\n\nclass BinaryExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['BinaryExpression', 'LogicalExpression'] }\n  \n  get left() { return this.children[0] }\n  get right() { return this.children[1] }\n    \n  labelString() {\n    let op = this.astNode.operator;\n    let left = this.left.valueString();\n    let right = this.right.valueString();\n    return `${left} ${op} ${right}`;\n  }\n}\n\nclass UnaryExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['UnaryExpression'] }\n  \n  get argument() { return this.children[0] }\n  \n  labelString() {\n    return this.astNode.operator;\n  }\n}\n\nclass MemberExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['MemberExpression'] }\n  \n  get computed() { return this.astNode.computed }\n  get object() { return this.children[0] }\n  get property() { return this.computed ? this.children[1].value : this.astNode.property.name }\n  \n  labelString() {\n    let object = this.object.valueString();\n    let property = this.property;\n    if (this.computed) {\n      return `${object}[${this.toDisplayString(property)}]`\n    } else {\n      return `${object}.${property}`\n    }\n  }\n}\n\nclass CallExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['CallExpression'] }\n    \n  get function() { return this.children[0].value }\n  get numArgs() { return this.children.length - (this.functionIsTraced() ? 2 : 1) }\n  get arguments() { return this.children.slice(1, this.numArgs + 1) }\n  get lastChild() { return this.children[this.children.length - 1] }\n  get call() { return this.functionIsTraced() ? this.lastChild : null }\n  get branchesControlFlow() { return true }\n  \n  functionIsTraced() {\n    return this.lastChild.isFunction;\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.arguments.forEach((node) => node.collectVariablesOfInterest(variables));\n    if (this.call) this.call.collectVariablesOfInterest(variables);\n  }\n  \n  labelString() {\n    let name = this.function.name || this.function.property;\n    if (typeof(name) != 'string') name = 'f';\n    let argString = this.arguments.map((expNode) => {\n      return expNode.valueString();\n    }).join(',');\n    return `${name}(${argString}) -> ${this.valueString()}`;\n  }\n}\n\nclass ObjectExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['ObjectExpression'] }\n  \n  labelString() {\n    return this.valueString();\n  }\n}\n\nclass ArrayExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['ArrayExpression'] }\n  \n  labelString() {\n    return this.valueString();\n  }\n}\n\nclass NewExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['NewExpression'] }\n  \n  labelString() {\n    return ` new ${this.valueString()}`; //there's probably something better to do here\n  }\n}\n\nclass ConditionalExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['ConditionalExpression'] }\n  \n  get branchesControlFlow() { return true }\n  get test() { return this.children[0] }\n  \n  labelString() {\n    return `${this.toDisplayString(!!this.test.value)} -> ${this.valueString()}`;\n  }\n}\n\nclass ReturnNode extends ExpressionNode {\n  static get astTypes() { return ['ReturnStatement'] }\n  \n  get argument() { return this.children[0] }\n  \n  hasArgument() {\n    return this.astNode.argument !== null;\n  }\n  \n  labelString() {\n    return this.hasArgument() ? `return ${this.valueString()}` : 'return';\n  }\n}\n\nclass IfStatementNode extends TraceNode {\n  static get astTypes() { return ['IfStatement'] }\n  \n  get test() { return this.children[0] }\n  get consequences() { return this.children.slice(1, this.children.length) }\n  get branchesControlFlow() { return true }\n  \n  labelString() {\n    return `if (${this.test.labelString()}) -> ${this.test.valueString()}`;\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.test.collectVariablesOfInterest(variables);\n  }\n}\n\nclass WhileStatementNode extends TraceNode {\n  static get astTypes() { return ['WhileStatement'] }\n  get branchesControlFlow() { return true }\n  \n  labelString() {\n    return 'while{}'\n  }\n}\n\nclass DoWhileStatementNode extends TraceNode {\n  static get astTypes() { return ['DoWhileStatement'] }\n  get branchesControlFlow() { return true }\n  \n  labelString() {\n    return 'do{}while'\n  }\n}\n\nclass VariableDeclarationNode extends TraceNode {\n  static get astTypes() { return ['VariableDeclaration'] }\n  get kind() { return this.astNode.kind; }\n  \n  get assignmentTargets() {\n    return this.children.reduce((vars, declarator) => {\n      return vars.concat(declarator.assignmentTargets);\n    }, []);\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.collectAssignmentTargets(variables);\n  }\n  \n  labelString() {\n    const vars = this.assignmentTargets.map((id) => id.name).join(\", \");\n    return `${this.astNode.kind} ${vars}`;\n  }\n}\n\nclass LiteralExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['Literal'] }\n  \n  labelString() {\n    return this.valueString();\n  }\n}\n\n/*\n * Variable Changes\n */\n\nclass VariableExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['Identifier'] }\n  get readsVariable() { return true }\n  get variable() { return this.scope.variableNamed(this.astNode.name) }\n  \n  end(...args) {\n    const variable = this.variable;\n    if (variable) variable.log(this); //todo: trace declarations, check against javascript globals\n    return super.end(...args);\n  }\n  \n  labelString() {\n    return this.astNode.name;\n  }\n  \n  collectVariablesOfInterest(variables) {\n    variables.add(this.variable);\n  }\n}\n\nclass DeclaratorNode extends ExpressionNode {\n  static get astTypes() { return ['VariableDeclarator'] }\n  get init() { return this.children[0] }\n  get declaration() { return this.parent; }\n  get kind() { return this.declaration.kind; }\n  get writesVariable() { return true }\n  \n  setVariableValues(...args) {\n    super.setVariableValues(...args);\n    this.assignmentTargets.forEach((id) => {\n      this.scope.declareVariable(id.name, this, this.kind);\n    })\n  }\n  \n  assigns(identifier) {\n    return this.assignmentTargets.some((id) => {\n      return equalIdentifiers(id, identifier);\n    });\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.collectAssignmentTargets(variables);\n    this.children.forEach((node) => node.collectVariablesOfInterest(variables));\n  }\n  \n  labelString() {\n    return this.astNode.init ? this.assignmentsString() : this.astNode.id.name;\n  }\n}\n\nclass AssignmentExpressionNode extends ExpressionNode {\n  static get astTypes() { return ['AssignmentExpression'] }\n  \n  get left() { return this.astNode.left }\n  get right() { return this.children[0] }\n  get identifiers() { \n    return this.assignmentTargets.filter((node) => t.isIdentifier(node));\n  }\n  get writesVariable() { return true }\n  \n  end(...args) {\n    this.identifiers.forEach((id) => {\n      this.scope.variableNamed(id.name).log(this);\n    })\n    return super.end(...args);\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.identifiers.forEach((id) => variables.add(this.scope.variableNamed(id.name)));\n    this.right.collectVariablesOfInterest(variables);\n  }\n  \n  assigns(identifier) {\n    return this.assignmentTargets.some((id) => {\n      return equalIdentifiers(id, identifier);\n    });\n  }\n  \n  labelString() {\n    return this.assignmentsString();\n  }\n}\n\nclass UpdateExpressionNode extends ExpressionNode { //subclass AssignmentExpressionNode?\n  static get astTypes() { return ['UpdateExpression'] }\n  \n  get identifier() {\n    if (t.isIdentifier(this.argument)) {\n      return this.argument;\n    } else {\n      return this.argument.identifier; //argument might not to be an identifier\n    }\n  }\n  get argument() { return this.astNode.argument }\n  get writesVariable() { return true }\n  get readsVariable() { return true }\n  \n  end(...args) {\n    this.scope.variableNamed(this.identifier.name).log(this);\n    return super.end(...args);\n  }\n  \n  labelString() {\n    return `${this.argument.name} = ${this.valueString()}`;\n  }\n  \n  collectVariablesOfInterest(variables) {\n    variables.add(this.scope.variableNamed(this.identifier.name));\n    this.children.forEach((node) => node.collectVariablesOfInterest(variables));\n  }\n  \n  assigns(identifier) {\n    return equalIdentifiers(this.identifier, identifier);\n  }\n}\n\n/*\n * Scopes\n */\n\nclass ScopeNode extends TraceNode {\n  constructor(...args) {\n    super(...args);\n    this.variables = {};\n  }\n  \n  get isScope() { return true }\n  \n  declareVariable(name, sourceNode, kind) {\n    this.variables[name] = new Variable(name, sourceNode, kind);\n  }\n  \n  variableNamed(name) {\n    const variable = this.variables[name];\n    if (variable) {\n      return this.variables[name];\n    } else {\n      const scope = this.scope;\n      return scope ? scope.variableNamed(name) : null;\n    }\n  }\n}\n\nclass ProgramNode extends ScopeNode {\n  static get astTypes() { return ['Program'] }\n  get branchesControlFlow() { return true } //might be seen as either\n  \n}\n\nclass BlockNode extends ScopeNode {\n  static get astTypes() { return ['BlockStatement'] }\n  \n  labelString() {\n    return ''\n  }\n}\n\nclass ForStatementNode extends ScopeNode {\n  static get astTypes() { return ['ForStatement'] }\n  \n  get branchesControlFlow() { return true }\n  \n  labelString() {\n    return 'for{}'\n  }\n}\n\nclass FunctionNode extends ScopeNode {\n  static get astTypes() { return ['Function'] }\n  \n  //getScope() {  } //todo: function's scope is set during its creation\n  get branchesControlFlow() { return true }\n  get isFunction() { return true }\n  \n  setVariableValues(...args) {\n    super.setVariableValues(...args);\n    this.assignmentTargets.forEach((id) => {\n      this.declareVariable(id.name, this, \"param\");\n    })\n  }\n  \n  collectVariablesOfInterest(variables) {\n    this.collectAssignmentTargets(variables);\n  }\n  \n  assigns(identifier) {\n    return this.assignmentTargets.some((id) => {\n      return equalIdentifiers(id, identifier);\n    });\n  }\n  \n  labelString() {\n    return `Function(${this.assignmentsString()})`;\n  }\n}\n\n/*\n * state\n */\n\nclass Variable {\n  constructor(name, source, kind) {\n    this.name = name;\n    this.history = [source];\n    this.type = kind; //var, let, const, param\n  }\n  \n  log(traceNode) {\n    this.history.push(traceNode);\n  }\n  \n  indexBefore(traceNode) {\n    for (let i = this.history.length - 1; i >= 0; i--) {\n      const node = this.history[i];\n      if (traceNode.isAfter(node)) return i;\n    }\n    return -1;\n  }\n  \n  indexAfter(traceNode) {\n    for (let i = 0; i < this.history.length; i++) {\n      const node = this.history[i];\n      if (traceNode.isBefore(node)) return i;\n    }\n    return this.history.length;\n  }\n  \n  findBefore(tester, traceNode) {\n    let i = this.indexBefore(traceNode);\n    while (i >= 0) {\n      const node = this.history[i--];\n      if (tester(node)) return node;\n    }\n    return null;\n  }\n  \n  findAfter(tester, traceNode) {\n    let i = this.indexAfter(traceNode);\n    while (i < this.history.length) {\n      const node = this.history[i++];\n      if (tester(node)) return node;\n    }\n    return null;\n  }\n  \n  writeBefore(traceNode) {\n    return this.findBefore((node) => node.writesVariable, traceNode);\n  }\n  \n  writeAfter(traceNode) {\n    return this.findAfter((node) => node.writesVariable, traceNode);\n  }\n  \n  readBefore(traceNode) {\n    return this.findBefore((node) => node.readsVariable, traceNode);\n  }\n  \n  readAfter(traceNode) {\n    return this.findAfter((node) => node.readsVariable, traceNode);\n  }\n  \n  readOrWriteBefore(traceNode) {\n    return this.findBefore((node) => true, traceNode);\n  }\n  \n  readOrWriteAfter(traceNode) {\n    return this.findAfter((node) => true, traceNode);\n  }\n}\n\nexport function equalIdentifiers(identifier1, identifier2) {\n  t.assertIdentifier(identifier1);\n  t.assertIdentifier(identifier2);\n  return (\n    identifier1.name == identifier2.name\n    && identifier1.scopeId == identifier2.scopeId)\n}\n\nwindow.lively4ExecutionTrace = ExecutionTrace"]}