{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-tabs/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","classFilePath","__classFilePath__","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","warn","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    if (location && location.file) {\n      DebuggingCache.updateFiles([location.file]);\n    }\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\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(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;"]}