{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-portal/src/client/reactive/active-expression-rewriting/active-expression-rewriting.js"],"names":["BaseActiveExpression","frameBasedAExpr","Stack","CompositeKey","InjectiveMap","BidirectionalMultiMap","DualKeyMap","isFunction","lively","_","AExprRegistry","DebuggingCache","Preferences","setGlobal","getGlobal","setLocal","getLocal","deleteMember","setMemberBitwiseOR","setMemberBitwiseXOR","setMemberBitwiseAND","setMemberUnsignedRightShift","setMemberRightShift","setMemberLeftShift","setMemberExponentiation","setMemberRemainder","setMemberDivision","setMemberMultiplication","setMemberSubtraction","setMemberAddition","setMember","updateMember","getAndCallMember","getMember","traceMember","reset","aexpr","getHooksInFile","getDependenciesAndHooksForAE","getAEDataForFile","analysisStack","expressionAnalysisMode","window","__expressionAnalysisMode__","ExpressionAnalysis","recalculateDependencies","findUp","currentAExpr","Error","withElement","dependencies","Set","value","isError","evaluateToCurrentValue","e","console","error","message","applyDependencies","top","associateDependency","dependency","add","currentDependencies","all","currentSet","removedDependencies","filter","has","newDependencies","forEach","DependenciesToAExprs","disassociate","associate","matching","index","findIndex","dependency2","equalish","push","removed","getKey","added","currentVersion","splice","length","logEvent","map","d","d1","d2","type","isEqual","Dependency","getOrCreateFor","context","identifier","ContextAndIdentifierToDependencies","getOrCreate","DependencyKey","constructor","_type","isTracked","hooks","updateTracking","hasAExprsForDep","untrack","track","hook","getHooks","getLocations","then","locations","updateFiles","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","addDependency","removeSecondary","removeDependency","undefined","notifyAExprs","location","aexprs","DependencyManager","checkAndNotifyAExprs","isMemberDependency","isLocalDependency","self","getName","toString","name","getAsDependencyDescription","object","property","scope","_depsToAExprs","dep","remove","disconnectAllForAExpr","deps","getDepsForAExpr","removeAllLeftFor","hasLeft","from","getRightsFor","hasRight","getLeftsFor","hasDepsForAExpr","clear","getAllLeft","url","result","getLocationCache","getAEsInFile","set","getDependencies","includes","allHooks","allValues","flatMap","hooksWithLocations","Promise","some","getDependency","equals","other","isArray","getCurrentVersion","getValue","identifer","DataStructureHookByDataStructure","WeakMap","PropertyWrappingHookByProperty","MutationObserverHookByHTMLElement","EventBasedHookByHTMLElement","Hook","installed","locationPromises","addLocation","addToMember","l","resolved","delete","informationString","notifyDependencies","debugging","TracingHandler","findRegistrationLocation","install","uninstall","monitorProperties","getPrototypeDescriptors","obj","proto","prototype","descriptors","Object","getOwnPropertyDescriptors","entries","key","desc","wrapProperty","descriptor","after","defineProperty","assign","args","apply","call","myself","prototypeDescriptors","ignoredDescriptorKeys","addDescriptor","__compareAExprResults__","configurable","enumerable","getOwnPropertyDescriptor","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","getDataBindingDependencyKey","isDataBinding","dataBindingDependencyKey","sharedDependenciesWith","otherAExpr","ownDependencies","otherDependencies","own","shared","computeDiff","_aexpr","locals","members","globals","globalRef","global","notificationQueue","cbStack","callbackStack","cbTop","info","resolve","resolvedLoc","parentAE","parentCallback","callback","slice","reverse","evaluationStack","infos","stackItem","sort","a","b","id","checkAndNotify","associateMember","prop","associateGlobal","globalName","associateLocal","varName","memberUpdated","globalUpdated","localUpdated","stack","frames","frame","getSourceLocBabelStyle","notificationFrame","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 { AExprRegistry } from 'src/client/reactive/active-expression/ae-registry.js';\n\nimport { DebuggingCache } from 'src/client/reactive/active-expression/ae-debugging-cache.js';\nimport Preferences from 'src/client/preferences.js';\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    \n    const currentDependencies = currentAExpr.dependencies().all();\n    const currentSet = new Set(currentDependencies);\n    let removedDependencies = currentDependencies\n      .filter(dependency => !dependencies.has(dependency));\n    const newDependencies = [...dependencies]\n      .filter(dependency => !currentSet.has(dependency));\n    \n    removedDependencies\n      .forEach(dependency => DependenciesToAExprs.disassociate(dependency, currentAExpr));\n    dependencies.forEach(dependency => {\n      DependenciesToAExprs.associate(dependency, currentAExpr);\n    });\n    \n    const matching = [];\n    removedDependencies = removedDependencies.filter((dependency) => {\n      const index = newDependencies.findIndex((dependency2 => this.equalish(dependency, dependency2)));\n      if(index >= 0) {\n        matching.push({removed: dependency.getKey(), added: newDependencies[index].getKey()});\n        dependency.currentVersion = newDependencies[index];\n        newDependencies.splice(index, 1);\n        return false;\n      }\n      return true;\n    });\n    if(newDependencies.length > 0 || removedDependencies.length > 0 || matching.length > 0) {\n      currentAExpr.logEvent('dependencies changed', { added: newDependencies.map(d => d.getKey()), removed: removedDependencies.map(d => d.getKey()), matching});\n    }\n  }\n\n  static equalish(d1, d2) {\n    if(d1.type() !== d2.type()) return false;\n    return _.isEqual(d1.getKey(), d2.getKey());\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\n\nconst DependenciesToAExprs = {\n  _depsToAExprs: new BidirectionalMultiMap(),\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    } \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    //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    const deps = [...this.getDepsForAExpr(aexpr)];\n    this._depsToAExprs.removeAllLeftFor(aexpr);\n    deps.forEach(dep => {      \n      dep.updateTracking()\n    });\n    if(deps.length > 0) {\n      aexpr.logEvent('dependencies changed', { added: [], removed: deps.map(d => d.getKey()), matching: []});\n    }\n    if (location && location.file) {\n      DebuggingCache.updateFiles([location.file]);\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  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\n\nexport async function getAEDataForFile(url) {\n  let result = new Map();\n  for (const ae of AExprRegistry.getLocationCache().getAEsInFile(url)) {\n    result.set(ae, getDependenciesAndHooksForAE(ae));\n  }\n  for (const hook of await getHooksInFile(url)) {\n    for(const dependency of hook.getDependencies()) {\n      for (const ae of DependenciesToAExprs.getAExprsForDep(dependency)) {\n        const location = ae.meta().get(\"location\");\n        if(!location) continue; // maybe if the ae has no location, we actually want to add it here?\n        const file = location.file;\n        // if the AE is also in this file, we already covered it with the previous loop\n        if (!file.includes(url)) {\n          result.getOrCreate(ae, () => []).push({ hook, dependency: dependency.getKey()})\n        }\n      }\n    }\n  }\n  return result;\n}\n\nfunction getDependenciesAndHooksForAE(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()});\n    }\n  }\n  return result;\n}\n\nexport async function 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    return locations.some(loc => loc && loc.file && loc.file.includes(url));\n  }).map(({ hook, locations }) => hook);\n}\n\n\nexport class 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    if(other.context === this.context) {\n      // Handle weird edgecase to deal with array[0] being the same as array[\"0\"]\n      if(Array.isArray(this.context)) {\n        if(typeof this.identifier !== typeof other.identifier) {\n          if(typeof this.identifier === \"string\") {\n            return this.identifier === (other.identifier + \"\");\n          }\n          if(typeof other.identifier === \"string\") {\n            return other.identifier === (this.identifier + \"\");\n          }\n        }\n      }\n      return other.identifier === this.identifier;\n    }\n    return false;\n  }\n  \n  getCurrentVersion() {\n    if(!this.currentVersion) {\n      return this;\n    } else {\n      this.currentVersion = this.currentVersion.getCurrentVersion();\n    }\n    return this.currentVersion;\n  }\n  \n  getValue() {\n    if(this.context instanceof Map) {\n      return this.context.get(this.identifier);      \n    } else if (this.context instanceof Set) {\n      return [...this.context][this.identifer];\n    } else {\n      return this.context[this.identifier];\n    }\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    this.locationPromises = new Set();\n  }\n\n  addLocation(location) {\n    if (!location) return;\n    const addToMember = (l) => {\n      if (l && !this.locations.some(loc => _.isEqual(loc, l))) {\n        this.locations.push(l);\n      }\n    };\n    if(location.then) {\n      this.locationPromises.add(location);\n      location.then((resolved) => {\n        this.locationPromises.delete(location);\n        addToMember(resolved);\n      });\n    } else {\n      addToMember(location);\n    }\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    await Promise.all(this.locationPromises);\n    return this.locations;\n  }\n\n  informationString() {\n    return \"Generic Hook\";\n  }\n\n  notifyDependencies(location) {\n    const debugging = Preferences.get(\"EnableAEDebugging\");\n    let loc;\n    if(debugging) {\n      loc = location || TracingHandler.findRegistrationLocation();\n      this.addLocation(loc);\n\n      this.getLocations().then(locations => DebuggingCache.updateFiles(locations.map(loc => loc.file)));      \n    }\n    for(const dep of [...this.dependencies]) {\n      if(debugging) {        \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      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\", \"get\", \"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    DependencyManager.disconnectAllFor(this);\n    super.dispose();\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  getDataBindingDependencyKey() {\n    if(!this.isDataBinding()) return undefined;\n    \n    if(!this.dataBindingDependencyKey) {\n      const {context, identifier} = this.meta().get('conceptInfo');\n      this.dataBindingDependencyKey = new DependencyKey(context, identifier);\n    }\n    return this.dataBindingDependencyKey;\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\nconst notificationQueue = [];\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    const cbStack = AExprRegistry.callbackStack;\n    const cbTop = cbStack[cbStack.length - 1];\n    const info = Promise.resolve(location).then((resolvedLoc) => {return {location: resolvedLoc, dependency: dependency.getKey(), hook, parentAE: cbTop && cbTop.ae, parentCallback: cbTop && cbTop.callback }});\n    aexprs.slice().reverse().forEach(ae => {\n      if(new Set(AExprRegistry.evaluationStack).has(ae)) return;\n      const infos = [info];\n      const index = notificationQueue.findIndex((stackItem) => stackItem.ae === ae);\n      if (index > -1) {\n        infos.push(...notificationQueue[index].infos);\n        notificationQueue.splice(index, 1);\n      }\n      //#ToDo: Insert in order of AE creation, to guarantee a topologically sorted graph for Signals. Signals before everything else?\n      notificationQueue.push({ae, infos});\n      notificationQueue.sort((a, b) => {      \n        if (a.ae.isDataBinding() !== b.ae.isDataBinding()) {\n          return b.ae.isDataBinding() ? 1 : -1;\n        } else {\n          return a.ae.id > b.ae.id ? 1 : -1;\n        }\n      });\n    });\n    \n    while(notificationQueue.length > 0) {\n      const {ae, infos} = notificationQueue[0];\n      //if(!aexprs.includes(ae)) return;\n      notificationQueue.splice(0, 1);\n      if(new Set(AExprRegistry.evaluationStack).has(ae)) continue;\n      ae.updateDependencies();\n      ae.checkAndNotify(infos);\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\") && !frame.file.includes(\"ContextJS\") && !frame.file.includes(\"<anonymous>\")) {\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    // lively.warn(\"findRegistrationLocation problem\", stack);\n    return frames[0];\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 updateMember(obj, prop, location) {\n  TracingHandler.memberUpdated(obj, prop, location);  \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;"]}