{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-tom/src/client/reactive/active-expression-rewriting/active-expression-rewriting.js"],"names":["BaseActiveExpression","frameBasedAExpr","Stack","CompositeKey","InjectiveMap","BidirectionalMultiMap","isFunction","lively","_","diff","setGlobal","getGlobal","setLocal","getLocal","deleteMember","setMemberBitwiseOR","setMemberBitwiseXOR","setMemberBitwiseAND","setMemberUnsignedRightShift","setMemberRightShift","setMemberLeftShift","setMemberExponentiation","setMemberRemainder","setMemberDivision","setMemberMultiplication","setMemberSubtraction","setMemberAddition","setMember","getAndCallMember","getMember","traceMember","reset","aexpr","relatedFiles","analysisStack","expressionAnalysisMode","window","__expressionAnalysisMode__","ExpressionAnalysis","recalculateDependencies","findUp","currentAExpr","Error","DependencyManager","disconnectAllFor","withElement","dependencies","Set","value","isError","evaluateToCurrentValue","applyDependencies","top","associateDependency","dependency","add","forEach","DependenciesToAExprs","associate","Dependency","getOrCreateFor","context","identifier","type","key","ContextAndIdentifierCompositeKey","for","CompositeKeyToDependencies","getOrCreateRightFor","constructor","_type","classFilePath","__classFilePath__","isTracked","updateTracking","hasAExprsForDep","untrack","track","contextIdentifierValue","isGlobal","isGlobalDependency","associateWithHook","SourceCodeHook","dataStructure","Array","Map","dataHook","DataStructureHookByDataStructure","getOrCreate","DataStructureHook","forStructure","wrappingHook","PropertyWrappingHook","getOrCreateForProperty","HTMLElement","tagName","endsWith","mutationObserverHook","MutationObserverHook","getOrCreateForElement","eventBasedHook","EventBasedHook","FrameBasedHook","instance","hook","HooksToDependencies","compKey","getLeftFor","removeRight","disconnectAllForDependency","hasLeft","remove","keysFor","undefined","notifyAExprs","location","aexprs","getAExprsForDep","checkAndNotifyAExprs","isMemberDependency","isLocalDependency","object","self","getHooks","getHooksForDep","getName","toString","name","getAsDependencyDescription","property","scope","AEDebuggingCache","registeredDebuggingViews","debouncedUpdateDebuggingViews","debounce","updateDebggingViews","changedFiles","registerFileForAEDebugging","url","triplesCallback","callback","valid","getDependencyTriplesForFile","push","getTripletsForAE","ae","result","getDepsForAExpr","updateFile","oldCode","newCode","lineMapping","calculateMapping","getAEsInFile","meta","get","remapLocation","getHooksInFile","getLocations","then","locations","e","console","error","lineChanged","start","line","diff2","lineChanged2","end","notify","mapping","dmp","diff_match_patch","a","diff_linesToChars_","lineText1","chars1","lineText2","chars2","lineArray","diffs","diff_main","originalLine","newLine","recentDeletions","recentAdditions","data","i","length","matchingLines","Math","max","substring","diff_charsToLines_","updateFiles","files","file","some","includes","splice","concat","getDepsForHook","DebuggingCache","_depsToAExprs","_AEsPerFile","dep","map","loc","disconnectAllForAExpr","has","delete","deps","removeAllLeftFor","aes","entries","from","getRightsFor","hasRight","getLeftsFor","hasDepsForAExpr","clear","getAllLeft","_hooksToDeps","hooksWithLocations","Promise","all","filter","find","hasDepsForHook","hasHooksForDep","CompositeKeyToSourceCodeHook","WeakMap","PropertyWrappingHookByProperty","MutationObserverHookByHTMLElement","EventBasedHookByHTMLElement","Hook","installed","addLocation","isEqual","l","informationString","notifyDependencies","TracingHandler","findRegistrationLocation","getRightFor","install","uninstall","getPrototypeDescriptors","obj","proto","prototype","descriptors","Object","getOwnPropertyDescriptors","desc","wrapProperty","descriptor","after","defineProperty","assign","args","apply","call","monitorProperties","prototypeDescriptors","addDescriptor","__compareAExprResults__","configurable","enumerable","getOwnPropertyDescriptor","set","element","_element","o","MutationObserver","mutations","observer","changeHappened","observe","attributes","attributeFilter","attributeOldValue","characterData","characterDataOldValue","childList","subtree","addEventListener","editor","on","_instance","initializeAe","x","isMeta","onChange","RewritingActiveExpression","func","strategy","updateDependencies","dispose","asAExpr","isDisabled","supportsDependencies","DependencyAPI","sharedDependenciesWith","otherAExpr","ownDependencies","otherDependencies","own","shared","other","computeDiff","_aexpr","getDependencies","locals","members","globals","globalRef","global","checkAndNotify","associateMember","prop","associateGlobal","globalName","associateLocal","varName","memberUpdated","globalUpdated","localUpdated","stack","frames","frame","slice","getSourceLocBabelStyle","log","val"],"mappings":"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","file":"active-expression-rewriting.js","sourcesContent":["import 'lang';\n\n/*HTML \n<img src=\"https://lively-kernel.org/lively4/lively4-core/media/lively4_logo_smooth_100.png\"></img>'s Implementation of AExprs\nHTML*/\n\nimport { BaseActiveExpression } from 'active-expression';\nimport * as frameBasedAExpr from \"active-expression-frame-based\";\n\nimport Stack from './../utils/stack.js';\nimport CompositeKey from './composite-key.js';\nimport InjectiveMap from './injective-map.js';\nimport BidirectionalMultiMap from './bidirectional-multi-map.js';\nimport { isFunction } from 'utils';\nimport lively from \"src/client/lively.js\";\nimport _ from 'src/external/lodash/lodash.js';\nimport diff from 'src/external/diff-match-patch.js';\n\n/*MD # Dependency Analysis MD*/\n\nconst analysisStack = new Stack();\n\nlet expressionAnalysisMode = false;\nwindow.__expressionAnalysisMode__ = false;\n\nclass ExpressionAnalysis {\n\n  static recalculateDependencies(aexpr) {\n    if (analysisStack.findUp(({ currentAExpr }) => currentAExpr === aexpr)) {\n      throw new Error('Attempt to recalculate an Active Expression while it is already recalculating dependencies');\n    }\n\n    // #TODO: compute diff of Dependencies\n    DependencyManager.disconnectAllFor(aexpr);\n\n    try {\n      expressionAnalysisMode = true;\n      window.__expressionAnalysisMode__ = expressionAnalysisMode;\n\n      // Do the function execution in ExpressionAnalysisMode\n      analysisStack.withElement({ currentAExpr: aexpr, dependencies: new Set() }, () => {\n        try {\n          const { value, isError } = aexpr.evaluateToCurrentValue();\n        } finally {\n          this.applyDependencies();\n        }\n      });\n    } finally {\n      expressionAnalysisMode = !!analysisStack.top();\n      window.__expressionAnalysisMode__ = expressionAnalysisMode;\n    }\n  }\n\n  static associateDependency(dependency) {\n    const { dependencies } = analysisStack.top();\n    dependencies.add(dependency);\n  }\n\n  static applyDependencies() {\n    const { currentAExpr, dependencies } = analysisStack.top();\n    dependencies.forEach(dependency => {\n      DependenciesToAExprs.associate(dependency, currentAExpr);\n    });\n  }\n\n}\n\nclass Dependency {\n  static getOrCreateFor(context, identifier, type) {\n    const key = ContextAndIdentifierCompositeKey.for(context, identifier);\n    return CompositeKeyToDependencies.getOrCreateRightFor(key, () => new Dependency(context, identifier, type));\n  }\n\n  // #TODO: compute and cache isGlobal\n  constructor(context, identifier, type) {\n    this._type = type;\n    this.classFilePath = context.__classFilePath__;\n    this.isTracked = false;\n  }\n\n  updateTracking() {\n    if (this.isTracked === DependenciesToAExprs.hasAExprsForDep(this)) {\n      return;\n    }\n    if (this.isTracked) {\n      this.untrack();\n    } else {\n      this.track();\n    }\n  }\n\n  track() {\n    this.isTracked = true;\n\n    const [context, identifier, value] = this.contextIdentifierValue();\n    const isGlobal = this.isGlobalDependency();\n\n    /*HTML <span style=\"font-weight: bold;\">Source Code Hook</span>: for anything <span style=\"color: green; font-weight: bold;\">members or locals</span> HTML*/\n    // always employ the source code hook\n    this.associateWithHook(SourceCodeHook.getOrCreateFor(context, identifier));\n\n    /*HTML <span style=\"font-weight: bold;\">Data Structure Hook</span>: for <span style=\"color: green; font-weight: bold;\">Sets, Arrays, Maps</span> HTML*/\n    let dataStructure;\n    if (this._type === 'member') {\n      dataStructure = context;\n    } else if (this._type === 'local') {\n      dataStructure = value;\n    }\n    if (dataStructure instanceof Array || dataStructure instanceof Set || dataStructure instanceof Map) {\n      const dataHook = DataStructureHookByDataStructure.getOrCreate(dataStructure, dataStructure => DataStructureHook.forStructure(dataStructure));\n      this.associateWithHook(dataHook);\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Wrapping Hook</span>: only for <span style=\"color: green; font-weight: bold;\">\"that\"</span> HTML*/\n    if (isGlobal && identifier === 'that') {\n      const wrappingHook = PropertyWrappingHook.getOrCreateForProperty(identifier);\n      this.associateWithHook(wrappingHook);\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Mutation Observer Hook</span>: handling <span style=\"color: green; font-weight: bold;\">HTMLElements</span> HTML*/\n    if (this._type === 'member' && context instanceof HTMLElement) {\n      // #HACK #TODO: for now, ignore Knotview if unused for Mutations -> need to better separate those hooks, e.g. do not recursively check ALL attribute change, etc.\n      if (context.tagName !== 'LIVELY-TABLE' && !(context.tagName === 'KNOT-VIEW' && (identifier === 'knot' || identifier === 'knotLabel')) && !context.tagName.endsWith('-rp19')) {\n        // TODO: the member also influences what kind of observer we want to use!\n        const mutationObserverHook = MutationObserverHook.getOrCreateForElement(context);\n        this.associateWithHook(mutationObserverHook);\n      }\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Event-based Change Hook</span>: handling <span style=\"color: green; font-weight: bold;\">HTMLElements</span> HTML*/\n    if (this._type === 'member' && context instanceof HTMLElement) {\n      const eventBasedHook = EventBasedHook.getOrCreateForElement(context);\n      // #TODO: we have to acknowledge that different properties require different events to listen on\n      //  e.g. code-mirror might have 'value' (so need to listen for 'change') or 'getCursor' (so need to listen for 'cursorActivity')\n      // eventBasedHook.listenFor(identifier);\n      this.associateWithHook(eventBasedHook);\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Frame-based Change Hook</span>: handling <span style=\"color: green; font-weight: bold;\">Date</span> HTML*/\n    // -    if ((this._type === 'member' && context === Date && identifier === 'now') ||\n    if (isGlobal && identifier === 'Date') {\n      this.associateWithHook(FrameBasedHook.instance);\n    }\n  }\n\n  associateWithHook(hook) {\n    HooksToDependencies.associate(hook, this);\n  }\n\n  untrack() {\n    this.isTracked = false;\n    const compKey = CompositeKeyToDependencies.getLeftFor(this);\n    CompositeKeyToDependencies.removeRight(this);\n    HooksToDependencies.disconnectAllForDependency(this);\n\n    if (!CompositeKeyToDependencies.hasLeft(compKey)) {\n      ContextAndIdentifierCompositeKey.remove(compKey);\n    }\n  }\n\n  contextIdentifierValue() {\n    const compKey = CompositeKeyToDependencies.getLeftFor(this);\n\n    const [context, identifier] = ContextAndIdentifierCompositeKey.keysFor(compKey);\n    const value = context !== undefined ? context[identifier] : undefined;\n\n    return [context, identifier, value];\n  }\n\n  notifyAExprs(location, hook) {\n    const aexprs = DependenciesToAExprs.getAExprsForDep(this);\n    DependencyManager.checkAndNotifyAExprs(aexprs, location, this, hook);\n  }\n\n  type() {\n    if(this.isGlobal()) return \"global\";\n    return this._type;\n  }\n  \n  isMemberDependency() {\n    return this._type === 'member' && !this.isGlobal();\n  }\n  isGlobalDependency() {\n    return this._type === 'member' && this.isGlobal();\n  }\n  isLocalDependency() {\n    return this._type === 'local';\n  }\n  isGlobal() {\n    const compKey = CompositeKeyToDependencies.getLeftFor(this);\n    if (!compKey) {\n      return false;\n    }\n    const [object] = ContextAndIdentifierCompositeKey.keysFor(compKey);\n    return object === self;\n  }\n  \n  getHooks() {\n    return HooksToDependencies.getHooksForDep(this);\n  }\n  \n  getName() {    \n    const [context, identifier] = this.contextIdentifierValue();\n\n    if (this.isGlobalDependency()) {\n      return identifier.toString()\n    }\n    return (context?context.constructor.name:\"\") + \".\" + identifier;\n  }\n\n  getAsDependencyDescription() {\n    const [context, identifier, value] = this.contextIdentifierValue();\n\n    if (this.isMemberDependency()) {\n      return {\n        object: context,\n        property: identifier,\n        value\n      };\n    }\n\n    if (this.isGlobalDependency()) {\n      return {\n        name: identifier,\n        value\n      };\n    }\n\n    if (this.isLocalDependency()) {\n      return {\n        scope: context,\n        name: identifier,\n        value\n      };\n    }\n\n    throw new Error('Dependency is neighter local, member, nor global.');\n  }\n\n}\n/*MD # Debugging Cache MD*/\n\nexport class AEDebuggingCache {\n\n  constructor() {\n    this.registeredDebuggingViews = [];\n    this.debouncedUpdateDebuggingViews = _.debounce(this.updateDebggingViews, 100);\n    this.changedFiles = new Set();\n  }\n  /*MD ## Registration MD*/\n  async registerFileForAEDebugging(url, context, triplesCallback) {\n    const callback = async () => {\n      if (context && (!context.valid || context.valid())) {\n        triplesCallback((await this.getDependencyTriplesForFile(url)));\n        return true;\n      }\n      return false;\n    };\n    this.registeredDebuggingViews.push({ callback, url });\n\n    triplesCallback((await this.getDependencyTriplesForFile(url)));\n  }\n\n  getTripletsForAE(ae) {\n    const result = [];\n    for (const dependency of DependenciesToAExprs.getDepsForAExpr(ae)) {\n      for (const hook of HooksToDependencies.getHooksForDep(dependency)) {\n        result.push({ hook, dependency, ae });\n      }\n    }\n    return result;\n  }\n\n  /*MD ## Caching MD*/\n\n  /*MD ## Code Change API MD*/\n  async updateFile(url, oldCode, newCode) {\n    try {\n      const lineMapping = this.calculateMapping(oldCode, newCode);\n      for (const ae of DependenciesToAExprs.getAEsInFile(url)) {\n        const location = ae.meta().get(\"location\");\n        this.remapLocation(lineMapping, location);\n      }\n      for (const hook of await HooksToDependencies.getHooksInFile(url)) {\n        hook.getLocations().then(locations => {\n          for (const location of locations) {\n            this.remapLocation(lineMapping, location);\n          }\n        });\n      }\n    } catch (e) {\n      console.error(e);\n    }\n  }\n\n  remapLocation(lineMapping, location) {\n    let [diff, lineChanged] = lineMapping[location.start.line];\n\n    if (diff === -1) {\n      location.start.line = 0;\n    } else {\n      location.start.line = diff;\n    }\n\n    let [diff2, lineChanged2] = lineMapping[location.end.line];\n\n    if (diff2 === -1) {\n      location.end.line = 0;\n    } else {\n      location.end.line = diff2;\n    }\n    if (lineChanged || lineChanged2) {\n      lively.notify(\"Changed AE code for existing AE. There are outdated expressions in the system\");\n      //ToDo: Check if the content is similar enough, mark AEs as outdated\n    }\n  }\n\n  calculateMapping(oldCode, newCode) {\n    const mapping = []; //For each line of oldCode: new Line in newCode if existing, changedContent if the line no longer exists but can be mapped to a newCode line\n    var dmp = new diff.diff_match_patch();\n    var a = dmp.diff_linesToChars_(oldCode, newCode);\n    var lineText1 = a.chars1;\n    var lineText2 = a.chars2;\n    var lineArray = a.lineArray;\n    var diffs = dmp.diff_main(lineText1, lineText2, false);\n\n    let originalLine = 0;\n    let newLine = 0;\n    let recentDeletions = 0;\n    let recentAdditions = 0;\n    for (let [type, data] of diffs) {\n      if (type === 0) {\n        recentDeletions = 0;\n        recentAdditions = 0;\n        for (let i = 0; i < data.length; i++) {\n          mapping[originalLine] = [newLine, false];\n          originalLine++;\n          newLine++;\n        }\n      } else if (type === 1) {\n        if (recentDeletions > 0) {\n          const matchingLines = Math.max(recentDeletions, data.length);\n          for (let i = 0; i < matchingLines; i++) {\n            mapping[originalLine - matchingLines + i] = [newLine, true];\n            newLine++;\n          }\n          data = data.substring(matchingLines);\n        }\n        if (data.length > 0) {\n          newLine += data.length;\n          recentAdditions += data.length;\n        }\n      } else {\n        if (recentAdditions > 0) {\n          const matchingLines = Math.max(recentAdditions, data.length);\n          for (let i = 0; i < matchingLines; i++) {\n            mapping[originalLine] = [newLine - matchingLines + i, true];\n            originalLine++;\n          }\n          data = data.substring(matchingLines);\n        }\n        recentDeletions += data.length;\n        for (let i = 0; i < data.length; i++) {\n          mapping[originalLine] = [-1, false];\n          originalLine++;\n        }\n      }\n    }\n\n    dmp.diff_charsToLines_(diffs, lineArray);\n\n    return mapping;\n  }\n  /*MD ## Rewriting API MD*/\n  updateFiles(files) {\n    if (!files) return;\n    files.forEach(file => this.changedFiles.add(file));\n    this.debouncedUpdateDebuggingViews();\n  }\n\n  async updateDebggingViews() {\n    for (let i = 0; i < this.registeredDebuggingViews.length; i++) {\n      if (![...this.changedFiles].some(file => file.includes(this.registeredDebuggingViews[i].url))) continue;\n      if (!(await this.registeredDebuggingViews[i].callback())) {\n        this.registeredDebuggingViews.splice(i, 1);\n        i--;\n      }\n    }\n    this.changedFiles = new Set();\n  }\n\n  async getDependencyTriplesForFile(url) {\n    let result = [];\n    for (const ae of DependenciesToAExprs.getAEsInFile(url)) {\n      result = result.concat(this.getTripletsForAE(ae));\n    }\n    for (const hook of await HooksToDependencies.getHooksInFile(url)) {\n      for (const dependency of HooksToDependencies.getDepsForHook(hook)) {\n        for (const ae of DependenciesToAExprs.getAExprsForDep(dependency)) {\n          const location = ae.meta().get(\"location\").file;\n          // if the AE is also in this file, we already covered it with the previous loop\n          if (!location.includes(url)) {\n            result.push({ hook, dependency, ae });\n          }\n        }\n      }\n    }\n    return result;\n  }\n\n}\n\nasync function relatedFiles(dependencies, aexprs) {}\n\nexport const DebuggingCache = new AEDebuggingCache();\n\nconst DependenciesToAExprs = {\n  _depsToAExprs: new BidirectionalMultiMap(),\n  _AEsPerFile: new Map(),\n\n  associate(dep, aexpr) {\n    const location = aexpr.meta().get(\"location\");\n    if (location && location.file) {\n      DebuggingCache.updateFiles([location.file]);\n      this._AEsPerFile.getOrCreate(location.file, () => new Set()).add(aexpr);\n    }\n    this._depsToAExprs.associate(dep, aexpr);\n    dep.updateTracking();\n\n    // Track affected files\n    for (const hook of HooksToDependencies.getHooksForDep(dep)) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n  },\n\n  disconnectAllForAExpr(aexpr) {\n    const location = aexpr.meta().get(\"location\");\n    if (location && location.file) {\n      DebuggingCache.updateFiles([location.file]);\n      if (this._AEsPerFile.has(location.file)) {\n        this._AEsPerFile.get(location.file).delete(aexpr);\n      }\n    }\n    const deps = this.getDepsForAExpr(aexpr);\n    this._depsToAExprs.removeAllLeftFor(aexpr);\n    deps.forEach(dep => dep.updateTracking());\n\n    // Track affected files\n    for (const dep of DependenciesToAExprs.getDepsForAExpr(aexpr)) {\n      for (const hook of HooksToDependencies.getHooksForDep(dep)) {\n        hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n      }\n    }\n  },\n\n  getAEsInFile(url) {\n    for (const [location, aes] of this._AEsPerFile.entries()) {\n      if (location.includes(url)) return aes;\n    }\n    return [];\n  },\n\n  getAExprsForDep(dep) {\n    if (!this._depsToAExprs.hasLeft(dep)) return [];\n    return Array.from(this._depsToAExprs.getRightsFor(dep));\n  },\n  getDepsForAExpr(aexpr) {\n    if (!this._depsToAExprs.hasRight(aexpr)) return [];\n    return Array.from(this._depsToAExprs.getLeftsFor(aexpr));\n  },\n\n  hasAExprsForDep(dep) {\n    return this.getAExprsForDep(dep).length >= 1;\n  },\n  hasDepsForAExpr(aexpr) {\n    return this.getDepsForAExpr(aexpr).length >= 1;\n  },\n\n  /*\n   * Removes all associations.\n   */\n  clear() {\n    this._depsToAExprs.clear();\n    this._depsToAExprs.getAllLeft().forEach(dep => dep.updateTracking());\n  }\n};\n\nconst HooksToDependencies = {\n  _hooksToDeps: new BidirectionalMultiMap(),\n\n  associate(hook, dep) {\n    this._hooksToDeps.associate(hook, dep);\n\n    // Track affected files\n    hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    for (const ae of DependenciesToAExprs.getAExprsForDep(dep)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\n    }\n  },\n\n  remove(hook, dep) {\n    this._hooksToDeps.remove(hook, dep);\n\n    // Track affected files\n    hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    for (const ae of DependenciesToAExprs.getAExprsForDep(dep)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\n    }\n  },\n\n  async getHooksInFile(url) {\n    const hooksWithLocations = await Promise.all(this._hooksToDeps.getAllLeft().map(hook => {\n      return hook.getLocations().then(locations => {\n        return { hook, locations };\n      });\n    }));\n    return hooksWithLocations.filter(({ hook, locations }) => {\n      const location = locations.find(loc => loc && loc.file);\n      return location && location.file.includes(url);\n    }).map(({ hook, locations }) => hook);\n  },\n\n  disconnectAllForDependency(dep) {\n    // Track affected files\n    for (const hook of HooksToDependencies.getHooksForDep(dep)) {\n      hook.untrack();\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    for (const ae of DependenciesToAExprs.getAExprsForDep(dep)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\n    }\n\n    this._hooksToDeps.removeAllLeftFor(dep);\n  },\n\n  getDepsForHook(hook) {\n    if (!this._hooksToDeps.hasLeft(hook)) return [];\n    return Array.from(this._hooksToDeps.getRightsFor(hook));\n  },\n  getHooksForDep(dep) {\n    if (!this._hooksToDeps.hasRight(dep)) return [];\n    return Array.from(this._hooksToDeps.getLeftsFor(dep));\n  },\n\n  hasDepsForHook(hook) {\n    return this.getDepsForHook(hook).length >= 1;\n  },\n  hasHooksForDep(dep) {\n    return this.getHooksForDep(dep).length >= 1;\n  },\n\n  /*\n   * Removes all associations.\n   */\n  clear() {\n    this._hooksToDeps.clear();\n  }\n};\n\n// 1. (obj, prop) or (scope, name) -> ContextAndIdentifierCompositeKey\n// - given via ContextAndIdentifierCompositeKey\nconst ContextAndIdentifierCompositeKey = new CompositeKey();\n\n// 2.1. ContextAndIdentifierCompositeKey 1<->1 Dependency\n// - CompositeKeyToDependencies\nconst CompositeKeyToDependencies = new InjectiveMap();\n// 2.2. Dependency *<->* AExpr\n// - DependenciesToAExprs\n\n/** Source Code Hooks */\n// 3.1. ContextAndIdentifierCompositeKey 1<->1 SourceCodeHook\n// - CompositeKeyToSourceCodeHook\nconst CompositeKeyToSourceCodeHook = new InjectiveMap();\n// 3.2. SourceCodeHook *<->* Dependency\n// - HooksToDependencies\n\n/** Data Structure Hooks */\n// 4.1 DataStructureHookByDataStructure\nconst DataStructureHookByDataStructure = new WeakMap(); // WeakMap<(Set/Array/Map), DataStructureHook>\n/** Wrapping Hooks */\n// 4.2 PropertyWrappingHookByProperty\nconst PropertyWrappingHookByProperty = new Map(); // Map<(String/Symbol), PropertyWrappingHook>\n/** Mutation Observer Hooks */\n// 4.3 DataStructureHookByDataStructure\nconst MutationObserverHookByHTMLElement = new WeakMap(); // WeakMap<HTMLElement, MutationObserverHook>\n/** XXX */\n// 4.4 XXX\nconst EventBasedHookByHTMLElement = new WeakMap(); // WeakMap<HTMLElement, EventBasedHook>\n\n\nclass Hook {\n  constructor() {\n    this.installed = false;\n    this.locations = [];\n  }\n\n  addLocation(location) {\n    if (!location) return;\n    if (!this.locations.some(loc => _.isEqual(loc, location))) {\n      this.locations.push(location);\n    }\n    //Todo: Promises get added multiple times... Also, use a Set?\n  }\n\n  async getLocations() {\n    this.locations = await Promise.all(this.locations);\n    this.locations = this.locations.filter(l => l);\n    return this.locations;\n  }\n\n  informationString() {\n    return \"Generic Hook\";\n  }\n\n  untrack() {}\n\n  notifyDependencies(location) {\n    const loc = location || TracingHandler.findRegistrationLocation();\n    this.addLocation(loc);\n    HooksToDependencies.getDepsForHook(this).forEach(dep => dep.notifyAExprs(loc, this));\n\n    this.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    for (const dep of HooksToDependencies.getDepsForHook(this)) {\n      for (const ae of DependenciesToAExprs.getAExprsForDep(dep)) {\n        if (ae.meta().has(\"location\")) {\n          DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n        }\n      }\n    }\n  }\n}\n\nclass SourceCodeHook extends Hook {\n  static getOrCreateFor(context, identifier) {\n    const compKey = ContextAndIdentifierCompositeKey.for(context, identifier);\n    return CompositeKeyToSourceCodeHook.getOrCreateRightFor(compKey, key => new SourceCodeHook(context, identifier));\n  }\n\n  static get(context, identifier) {\n    const compKey = ContextAndIdentifierCompositeKey.for(context, identifier);\n    return CompositeKeyToSourceCodeHook.getRightFor(compKey);\n  }\n\n  informationString() {\n    return \"SourceCodeHook: \" + this.context + \".\" + this.identifier;\n  }\n\n  untrack() {\n    CompositeKeyToSourceCodeHook.removeRight(this);\n  }\n\n  constructor(context, identifier) {\n    super();\n\n    this.context = context;\n    this.identifier = identifier;\n  }\n\n  install() {}\n  uninstall() {}\n}\n\nclass DataStructureHook extends Hook {\n  static forStructure(dataStructure) {\n    const hook = new DataStructureHook();\n\n    function getPrototypeDescriptors(obj) {\n      const proto = obj.constructor.prototype;\n\n      const descriptors = Object.getOwnPropertyDescriptors(proto);\n      return Object.entries(descriptors).map(([key, desc]) => (desc.key = key, desc));\n    }\n\n    function wrapProperty(obj, descriptor, after) {\n      Object.defineProperty(obj, descriptor.key, Object.assign({}, descriptor, {\n        value(...args) {\n          try {\n            return descriptor.value.apply(this, args);\n          } finally {\n            after.call(this, ...args);\n          }\n        }\n      }));\n    }\n\n    function monitorProperties(obj) {\n      const prototypeDescriptors = getPrototypeDescriptors(obj);\n      Object.entries(Object.getOwnPropertyDescriptors(obj)); // unused -> need for array\n\n      prototypeDescriptors.filter(descriptor => descriptor.key !== 'constructor' // the property constructor needs to be a constructor if called (as in cloneDeep in lodash); We leave it out explicitly as the constructor does not change any state #TODO\n      ).forEach(addDescriptor => {\n        // var addDescriptor = prototypeDescriptors.find(d => d.key === 'add')\n        if (addDescriptor.value) {\n          if (isFunction(addDescriptor.value)) {\n            wrapProperty(obj, addDescriptor, function () {\n              // #HACK #TODO we need an `withoutLayer` equivalent here\n              if (window.__compareAExprResults__) {\n                return;\n              }\n\n              this; // references the modified container\n              hook.notifyDependencies();\n            });\n          } else {\n            // console.warn(`Property ${addDescriptor.key} has a value that is not a function, but ${addDescriptor.value}.`)\n          }\n        } else {\n            // console.warn(`Property ${addDescriptor.key} has no value.`)\n          }\n      });\n    }\n\n    monitorProperties(dataStructure);\n\n    // set.add = function add(...args) {\n    //   const result = Set.prototype.add.call(this, ...args);\n    //   hook.notifyDependencies();\n    //   return result;\n    // }\n    return hook;\n  }\n\n  informationString() {\n    return \"DataStructureHook\";\n  }\n}\n\nclass PropertyWrappingHook extends Hook {\n  static getOrCreateForProperty(property) {\n    return PropertyWrappingHookByProperty.getOrCreate(property, () => new PropertyWrappingHook(property));\n  }\n\n  constructor(property) {\n    super();\n\n    this.property = property;\n    this.value = self[property];\n    const { configurable, enumerable } = Object.getOwnPropertyDescriptor(self, property);\n\n    // #TODO: keep old property accessors if present (otherwise, we do not interact with COP and ourselves, i.e. other property wrappers)\n    Object.defineProperty(self, property, {\n      configurable,\n      enumerable,\n\n      get: () => this.value,\n      set: value => {\n        const result = this.value = value;\n        this.notifyDependencies();\n        return result;\n      }\n    });\n  }\n\n  informationString() {\n    return \"PropertyWrappingHook: \" + this.property;\n  }\n}\n\nclass MutationObserverHook extends Hook {\n  static getOrCreateForElement(element) {\n    return MutationObserverHookByHTMLElement.getOrCreate(element, () => new MutationObserverHook(element));\n  }\n\n  constructor(element) {\n    super();\n\n    this._element = element;\n\n    const o = new MutationObserver((mutations, observer) => {\n      // const mutationRecords = o.takeRecords();\n      // lively.notify(`mutation on ${this._element.tagName}; ${mutations\n      //               .filter(m => m.type === \"attributes\")\n      //               .map(m => m.attributeName).join(', ')}.`)\n      this.changeHappened();\n      // mutations.forEach(mutation => {\n      //   if(mutation.type == \"attributes\") {\n      //     lively.notify(\n      //       `${mutation.oldValue} -> ${mutation.target.getAttribute(mutation.attributeName)}`,\n      //       `attribute: ${mutation.attributeName}`\n      //     );\n      //   }\n      //   if(mutation.type == \"characterData\") {\n      //     lively.notify(\n      //       `${mutation.oldValue}}`,\n      //       `characterData`\n      //     );\n      //   }\n      //   if(mutation.type == \"childList\") {\n      //     lively.success(\n      //       `${mutation.addedNodes.length} added, ${mutation.removedNodes.length} removed`,\n      //       `childList`\n      //     );\n      //   }\n      // });\n    });\n\n    o.observe(this._element, {\n      attributes: true,\n      attributeFilter: undefined,\n      attributeOldValue: true,\n\n      characterData: true,\n      characterDataOldValue: true,\n\n      childList: true,\n\n      subtree: true\n    });\n\n    // o.disconnect();\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n\n  informationString() {\n    return \"MutationObserverHook: \" + this._element;\n  }\n}\n\nclass EventBasedHook extends Hook {\n  static getOrCreateForElement(element) {\n    return EventBasedHookByHTMLElement.getOrCreate(element, () => new EventBasedHook(element));\n  }\n\n  constructor(element) {\n    super();\n\n    this._element = element;\n\n    // #TODO: when the type of an input element changes, 'value' or 'checked' become unavailable\n    if (this._element.tagName === 'INPUT' || this._element.tagName === 'TEXTAREA') {\n      this._element.addEventListener('input', () => {\n        this.changeHappened();\n      });\n    } else if (this._element.tagName === 'LIVELY-CODE-MIRROR') {\n      this._element.editor.on('changes', () => {\n        this.changeHappened();\n      });\n    }\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n\n  informationString() {\n    return \"EventBasedHook: \" + this._element;\n  }\n}\n\nclass FrameBasedHook extends Hook {\n  static get instance() {\n    if (!this._instance) {\n      this._instance = new FrameBasedHook();\n      //Initialization is split to avoid endless recursion\n      this._instance.initializeAe();\n    }\n    return this._instance;\n  }\n\n  initializeAe() {\n    let x = 0;\n    // #TODO: caution, we currently use a side-effect function! How can we mitigate this? E.g. using `Date.now()` as expression\n    let ae = frameBasedAExpr.aexpr(() => x++);\n    ae.isMeta(true);\n    ae.onChange(() => {\n      this.changeHappened();\n    });\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n\n  informationString() {\n    return \"FrameBasedHook\";\n  }\n}\n\nexport class RewritingActiveExpression extends BaseActiveExpression {\n  constructor(func, ...args) {\n    super(func, ...args);\n    this.meta({ strategy: 'Rewriting' });\n    this.updateDependencies();\n  }\n\n  dispose() {\n    super.dispose();\n    DependencyManager.disconnectAllFor(this);\n  }\n\n  // #TODO: why is this defined here, and not in the superclass?\n  asAExpr() {\n    return this;\n  }\n\n  updateDependencies() {\n    if (this.isDisabled()) {\n      return;\n    }\n\n    ExpressionAnalysis.recalculateDependencies(this);\n  }\n  supportsDependencies() {\n    return true;\n  }\n\n  dependencies() {\n    return new DependencyAPI(this);\n  }\n\n  sharedDependenciesWith(otherAExpr) {\n    const ownDependencies = this.dependencies().all();\n    const otherDependencies = otherAExpr.dependencies().all();\n    const [own, shared, other] = ownDependencies.computeDiff(otherDependencies);\n    return shared;\n  }\n}\n\nclass DependencyAPI {\n  constructor(aexpr) {\n    this._aexpr = aexpr;\n  }\n\n  getDependencies() {\n    return DependenciesToAExprs.getDepsForAExpr(this._aexpr);\n  }\n\n  all() {\n    return Array.from(this.getDependencies());\n  }\n\n  locals() {\n    return this.getDependencies().filter(dependency => dependency.isLocalDependency()).map(dependency => dependency.getAsDependencyDescription());\n  }\n\n  members() {\n    return this.getDependencies().filter(dependency => dependency.isMemberDependency()).map(dependency => dependency.getAsDependencyDescription());\n  }\n\n  globals() {\n    return this.getDependencies().filter(dependency => dependency.isGlobalDependency()).map(dependency => dependency.getAsDependencyDescription());\n  }\n}\n\nexport function aexpr(func, ...args) {\n  return new RewritingActiveExpression(func, ...args);\n}\n\nconst globalRef = typeof window !== \"undefined\" ? window : // browser tab\ntypeof self !== \"undefined\" ? self : // web worker\nglobal; // node.js\n\nclass DependencyManager {\n  // #TODO, #REFACTOR: extract into own method; remove from this class\n  static disconnectAllFor(aexpr) {\n    DependenciesToAExprs.disconnectAllForAExpr(aexpr);\n  }\n\n  // #TODO, #REFACTOR: extract into configurable dispatcher class\n  static checkAndNotifyAExprs(aexprs, location, dependency, hook) {\n    aexprs.forEach(aexpr => aexpr.updateDependencies());\n    aexprs.forEach(aexpr => aexpr.checkAndNotify(location, dependency, hook));\n  }\n\n  /**\n   * **************************************************************\n   * ********************** associate *****************************\n   * **************************************************************\n   */\n  static associateMember(obj, prop) {\n    const dependency = Dependency.getOrCreateFor(obj, prop, 'member');\n    ExpressionAnalysis.associateDependency(dependency);\n  }\n\n  static associateGlobal(globalName) {\n    const dependency = Dependency.getOrCreateFor(globalRef, globalName, 'member');\n    ExpressionAnalysis.associateDependency(dependency);\n  }\n\n  static associateLocal(scope, varName) {\n    const dependency = Dependency.getOrCreateFor(scope, varName, 'local');\n    ExpressionAnalysis.associateDependency(dependency);\n  }\n\n}\n\nclass TracingHandler {\n\n  /**\n   * **************************************************************\n   * ********************** update ********************************\n   * **************************************************************\n   */\n  static memberUpdated(obj, prop, location) {\n    const hook = SourceCodeHook.get(obj, prop);\n    if (!hook) return;\n    hook.notifyDependencies(location);\n  }\n\n  static globalUpdated(globalName, location) {\n    const hook = SourceCodeHook.get(globalRef, globalName);\n    if (!hook) return;\n    hook.notifyDependencies(location);\n  }\n\n  static localUpdated(scope, varName, location) {\n    const hook = SourceCodeHook.get(scope, varName);\n    if (!hook) return;\n    hook.notifyDependencies(location);\n  }\n\n  static async findRegistrationLocation() {\n    if (lively === undefined) return undefined;\n    const stack = lively.stack();\n    const frames = stack.frames;\n\n    for (let frame of frames.slice()) {\n      if (!frame.file.includes(\"active-expression\")) {\n        return await frame.getSourceLocBabelStyle();\n      }\n    }\n\n    for (let frame of frames.slice()) {\n      if (frame.func.includes(\".notifyDependencies\")) {\n        return await frame.getSourceLocBabelStyle();\n      }\n    }\n    console.log(stack);\n    return undefined;\n  }\n\n}\n\n/*\n * Disconnects all associations between active expressions and object properties\n * As a result no currently enable active expression will be notified again,\n * effectively removing them from the system.\n *\n * #TODO: Caution, this might break with some semantics, if we still have references to an aexpr!\n */\nexport function reset() {\n  ContextAndIdentifierCompositeKey.clear();\n\n  CompositeKeyToDependencies.clear();\n  DependenciesToAExprs.clear();\n\n  CompositeKeyToSourceCodeHook.clear();\n  HooksToDependencies.clear();\n}\n\n/*MD # Source Code Point Cuts MD*/\n/**\n * (C)RUD for member attributes\n */\nexport function traceMember(obj, prop) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n}\n\nexport function getMember(obj, prop) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n  const result = obj[prop];\n  return result;\n}\n\nexport function getAndCallMember(obj, prop, args = []) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n  const result = obj[prop](...args);\n  return result;\n}\n\nexport function setMember(obj, prop, val, location) {\n  const result = obj[prop] = val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberAddition(obj, prop, val, location) {\n  const result = obj[prop] += val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberSubtraction(obj, prop, val, location) {\n  const result = obj[prop] -= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberMultiplication(obj, prop, val, location) {\n  const result = obj[prop] *= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberDivision(obj, prop, val, location) {\n  const result = obj[prop] /= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberRemainder(obj, prop, val, location) {\n  const result = obj[prop] %= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberExponentiation(obj, prop, val, location) {\n  const result = obj[prop] **= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberLeftShift(obj, prop, val, location) {\n  const result = obj[prop] <<= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberRightShift(obj, prop, val, location) {\n  const result = obj[prop] >>= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberUnsignedRightShift(obj, prop, val, location) {\n  const result = obj[prop] >>>= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberBitwiseAND(obj, prop, val, location) {\n  const result = obj[prop] &= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberBitwiseXOR(obj, prop, val, location) {\n  const result = obj[prop] ^= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function setMemberBitwiseOR(obj, prop, val, location) {\n  const result = obj[prop] |= val;\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function deleteMember(obj, prop, location) {\n  const result = delete obj[prop];\n  TracingHandler.memberUpdated(obj, prop, location);\n  return result;\n}\n\nexport function getLocal(scope, varName, value) {\n  if (expressionAnalysisMode) {\n    scope[varName] = value;\n    DependencyManager.associateLocal(scope, varName);\n  }\n}\n\nexport function setLocal(scope, varName, value, location) {\n  scope[varName] = value;\n  TracingHandler.localUpdated(scope, varName, location);\n}\n\nexport function getGlobal(globalName) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateGlobal(globalName);\n  }\n}\n\nexport function setGlobal(globalName, location) {\n  TracingHandler.globalUpdated(globalName, location);\n}\n\nexport default aexpr;"]}