{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-leo/src/client/reactive/active-expression-rewriting/active-expression-rewriting.js"],"names":["BaseActiveExpression","frameBasedAExpr","Stack","CompositeKey","InjectiveMap","BidirectionalMultiMap","DualKeyMap","isFunction","lively","_","diff","AExprRegistry","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","withElement","dependencies","Set","value","isError","evaluateToCurrentValue","e","console","error","message","applyDependencies","top","associateDependency","dependency","add","all","filter","has","forEach","DependenciesToAExprs","disassociate","associate","Dependency","getOrCreateFor","context","identifier","type","ContextAndIdentifierToDependencies","getOrCreate","getKey","DependencyKey","constructor","_type","classFilePath","__classFilePath__","isTracked","hooks","updateTracking","hasAExprsForDep","untrack","track","hook","getHooks","getLocations","then","locations","DebuggingCache","updateFiles","map","loc","file","ae","getAExprsForDep","meta","get","contextIdentifierValue","isGlobal","isGlobalDependency","sourceCodeHook","SourceCodeHook","associateWithHook","dataStructure","Array","Map","DataStructureHook","getOrCreateForDataStructure","wrappingHook","PropertyWrappingHook","getOrCreateForProperty","HTMLElement","tagName","endsWith","MutationObserverHook","getOrCreateForElement","EventBasedHook","FrameBasedHook","instance","push","addDependency","removeSecondary","removeDependency","undefined","notifyAExprs","location","aexprs","DependencyManager","checkAndNotifyAExprs","isMemberDependency","isLocalDependency","self","getName","toString","name","getAsDependencyDescription","object","property","scope","AEDebuggingCache","registeredDebuggingViews","debouncedUpdateDebuggingViews","debounce","updateDebggingViews","changedFiles","registerFileForAEDebugging","url","triplesCallback","callback","valid","getDependencyTriplesForFile","getTripletsForAE","result","getDepsForAExpr","updateFile","oldCode","newCode","lineMapping","calculateMapping","getAEsInFile","remapLocation","getHooksInFile","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_","files","some","includes","splice","concat","getDependencies","allHooks","allValues","flatMap","dep","hooksWithLocations","Promise","find","_depsToAExprs","_AEsPerFile","logEvent","remove","disconnectAllForAExpr","delete","deps","removeAllLeftFor","aes","entries","hasLeft","from","getRightsFor","hasRight","getLeftsFor","hasDepsForAExpr","clear","getAllLeft","getDependency","equals","other","DataStructureHookByDataStructure","WeakMap","PropertyWrappingHookByProperty","MutationObserverHookByHTMLElement","EventBasedHookByHTMLElement","Hook","installed","addLocation","isEqual","l","informationString","notifyDependencies","TracingHandler","findRegistrationLocation","install","uninstall","monitorProperties","getPrototypeDescriptors","obj","proto","prototype","descriptors","Object","getOwnPropertyDescriptors","key","desc","wrapProperty","descriptor","after","defineProperty","assign","args","apply","call","myself","prototypeDescriptors","ignoredDescriptorKeys","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","disconnectAllFor","asAExpr","isDisabled","supportsDependencies","DependencyAPI","sharedDependenciesWith","otherAExpr","ownDependencies","otherDependencies","own","shared","computeDiff","_aexpr","locals","members","globals","globalRef","global","evaluationStack","checkAndNotify","associateMember","prop","associateGlobal","globalName","associateLocal","varName","memberUpdated","globalUpdated","localUpdated","stack","frames","frame","slice","getSourceLocBabelStyle","notificationFrame","findIndex","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 DualKeyMap from './dual-key-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';\nimport { AExprRegistry } from 'src/client/reactive/active-expression/active-expression.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    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        } catch(e) {\n          console.error(\"Error during AE Dependency Calculation\", e.message);\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    currentAExpr.dependencies().all()\n      .filter(dependency => !dependencies.has(dependency))\n      .forEach(dependency => DependenciesToAExprs.disassociate(dependency, currentAExpr));\n    dependencies.forEach(dependency => {\n      DependenciesToAExprs.associate(dependency, currentAExpr);\n    });\n  }\n\n}\n\nclass Dependency {\n  static getOrCreateFor(context, identifier, type) {\n    return ContextAndIdentifierToDependencies.getOrCreate(context, identifier, () => new Dependency(context, identifier, type));\n  }\n  \n  // Generates a key for this dependency. This allows this dependency to be found again at a later time, after the originial dependency might have already been deleted.\n  getKey() {\n    return new DependencyKey(this.context, this.identifier);\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    this.hooks = [];\n    this.context = context;\n    this.identifier = identifier;\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    for (const hook of this.getHooks()) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    for (const ae of DependenciesToAExprs.getAExprsForDep(this)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\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.sourceCodeHook = new SourceCodeHook(context, identifier);\n    this.associateWithHook(this.sourceCodeHook);\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      this.associateWithHook(DataStructureHook.getOrCreateForDataStructure(dataStructure));\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        this.associateWithHook(MutationObserverHook.getOrCreateForElement(context));\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      // #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.getOrCreateForElement(context));\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      //TODO: This violates the each Hook belongs to one Dependency Rule\n      this.associateWithHook(FrameBasedHook.instance);\n    }\n  }\n\n  associateWithHook(hook) {\n    this.hooks.push(hook);\n    hook.addDependency(this);\n  }\n\n  untrack() {\n    this.isTracked = false;\n    ContextAndIdentifierToDependencies.removeSecondary(this.context, this.identifier);\n\n    // Track affected files\n    for (const hook of this.hooks) {\n      hook.removeDependency(this);\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    for (const ae of DependenciesToAExprs.getAExprsForDep(this)) {\n      if (ae.meta().has(\"location\")) {\n        DebuggingCache.updateFiles([ae.meta().get(\"location\").file]);\n      }\n    }\n  }\n\n  //Todo: Replace\n  contextIdentifierValue() {\n    const value = this.context !== undefined ? this.context[this.identifier] : undefined;\n\n    return [this.context, this.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    return this.context === self;\n  }\n\n  getHooks() {\n    return this.hooks;\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 dependency.getHooks()) {\n        result.push({ hook, dependency: dependency.getKey(), 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 this.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 => {\n      if(file) {\n        this.changedFiles.add(file)\n      }\n    });\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 this.getHooksInFile(url)) {\n      for(const dependency of hook.getDependencies()) {\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: dependency.getKey(), ae });\n          }\n        }\n      }\n    }\n    return result;\n  }\n\n  async getHooksInFile(url) {\n    const allHooks = ContextAndIdentifierToDependencies.allValues().flatMap(dep => dep.getHooks());\n    const hooksWithLocations = await Promise.all(allHooks.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}\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    if(this._depsToAExprs.has(dep, aexpr)) return;\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    aexpr.logEvent('dependency added', { dependency: dep.getKey()});\n    this._depsToAExprs.associate(dep, aexpr);\n    dep.updateTracking();\n\n    // Track affected files\n    for (const hook of dep.getHooks()) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n  },\n  \n  disassociate(dep, aexpr) {\n    this._depsToAExprs.remove(dep, aexpr);\n    dep.updateTracking();\n    for (const hook of dep.getHooks()) {\n      hook.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    }\n    aexpr.logEvent('dependency removed', { dependency: dep.getKey()});\n    //TODO: Remove AE from assiciated file, if it was the last dependency?\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 => {      \n      aexpr.logEvent('dependency removed', { dependency: dep.getKey()});\n      dep.updateTracking()\n    });\n\n    // Track affected files\n    for (const dep of deps) {\n      for (const hook of dep.getHooks()) {\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\nclass DependencyKey {\n  constructor(context, identifier) {\n    this.context = context;\n    this.identifier = identifier;\n  }\n  \n  getDependency() {    \n    return ContextAndIdentifierToDependencies.get(this.context, this.identifier);\n  }\n  \n  equals(other) {\n    return other.context === this.context && other.identifier === this.identifier;\n  }\n}\n\n// 1. Two step map with (obj|scope) as primary key and (prop|name) as secondary key mapping to the dependencies\nconst ContextAndIdentifierToDependencies = new DualKeyMap();\n\n//const ContextToIdentifier = new MultiMap();\n//const IdentifierToDependency = new InjectiveMap();\n// 1. (obj, prop) or (scope, name) -> ContextAndIdentifierCompositeKey\n// - given via ContextAndIdentifierCompositeKey\n\n// 2.1. ContextAndIdentifierCompositeKey 1<->1 Dependency\n// - CompositeKeyToDependencies\n//const CompositeKeyToDependencies = new InjectiveMap();\n// 2.2. Dependency *<->* AExpr\n// - DependenciesToAExprs\n\n/** Source Code Hooks */\n// 3.1. ContextAndIdentifierCompositeKey 1<->1 SourceCodeHook\n// - CompositeKeyToSourceCodeHook\n//const 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\nclass Hook {\n  constructor() {\n    this.dependencies = new Set();\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  getDependencies() {\n    return this.dependencies;\n  }\n\n  addDependency(dependency) {\n    this.dependencies.add(dependency);\n  }\n\n  removeDependency(dependency) {\n    this.dependencies.delete(dependency);\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  notifyDependencies(location) {\n    const loc = location || TracingHandler.findRegistrationLocation();\n    this.addLocation(loc);\n\n    this.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));\n    for(const dep of [...this.dependencies]) {\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      dep.notifyAExprs(loc, this);\n    }\n  }\n}\n\nclass SourceCodeHook extends Hook {\n\n  informationString() {\n    return \"SourceCodeHook: \" + this.context + \".\" + this.identifier;\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 getOrCreateForDataStructure(dataStructure) {\n    return DataStructureHookByDataStructure.getOrCreate(dataStructure, () => new DataStructureHook(dataStructure));\n  }\n  constructor(dataStructure) {\n    super();\n    this.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  }\n\n  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  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  monitorProperties(obj) {\n    const myself = this;\n    const prototypeDescriptors = this.getPrototypeDescriptors(obj);\n    Object.entries(Object.getOwnPropertyDescriptors(obj)); // unused -> need for array\n\n    // the property constructor needs to be a constructor if called (as in cloneDeep in lodash);\n    // We can also leave out functions that do not change the state\n    const ignoredDescriptorKeys = new Set([\"at\", \"constructor\", \"concat\", \"entries\", \"every\", \"filter\", \"find\", \"findIndex\", \"forEach\", \"includes\", \"indexOf\", \"join\", \"keys\", \"lastIndexOf\", \"reduce\", \"reduceRight\", \"slice\", \"toString\", \"toLocaleString\", \"values\"]);\n    \n    prototypeDescriptors\n      .filter(descriptor => !ignoredDescriptorKeys.has(descriptor.key))\n      .forEach(addDescriptor => {\n      // var addDescriptor = prototypeDescriptors.find(d => d.key === 'add')\n      if (addDescriptor.value) {\n        if (isFunction(addDescriptor.value)) {\n          this.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            myself.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  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    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  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 => {\n      if(new Set(AExprRegistry.evaluationStack()).has(aexpr)) return;\n      aexpr.updateDependencies();\n      aexpr.checkAndNotify(location, dependency.getKey(), hook);\n    });\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 dependency = ContextAndIdentifierToDependencies.get(obj, prop);\n    if (!dependency || !dependency.sourceCodeHook) return;\n    dependency.sourceCodeHook.notifyDependencies(location);\n  }\n\n  static globalUpdated(globalName, location) {\n    const dependency = ContextAndIdentifierToDependencies.get(globalRef, globalName);\n    if (!dependency || !dependency.sourceCodeHook) return;\n    dependency.sourceCodeHook.notifyDependencies(location);\n  }\n\n  static localUpdated(scope, varName, location) {\n    const dependency = ContextAndIdentifierToDependencies.get(scope, varName);\n    if (!dependency || !dependency.sourceCodeHook) return;\n    dependency.sourceCodeHook.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    const notificationFrame = frames.findIndex(frame => frame.func.includes(\".notifyDependencies\"));\n    if(notificationFrame >= 0 && notificationFrame < frames.length - 1) {      \n      return await frames[notificationFrame + 1].getSourceLocBabelStyle();\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  ContextAndIdentifierToDependencies.clear();\n  DependenciesToAExprs.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;"]}