{"version":3,"sources":["https://lively-kernel.org/lively4/lively4-augment/src/client/reactive/active-expression-rewriting/active-expression-rewriting.js"],"names":["BaseActiveExpression","frameBasedAExpr","Stack","CompositeKey","InjectiveMap","BidirectionalMultiMap","using","isFunction","expressionAnalysisMode","window","__expressionAnalysisMode__","analysisModeManager","__enter__","__exit__","aexprStack","top","ExpressionAnalysis","recalculateDependencies","aexpr","DependencyManager","disconnectAllFor","check","value","isError","withElement","result","evaluateToCurrentValue","Dependency","getOrCreateFor","context","identifier","type","key","ContextAndIdentifierCompositeKey","for","CompositeKeyToDependencies","getOrCreateRightFor","constructor","_type","isTracked","updateTracking","DependenciesToAExprs","hasAExprsForDep","untrack","track","contextIdentifierValue","isGlobal","isGlobalDependency","HooksToDependencies","associate","SourceCodeHook","dataStructure","Array","Set","Map","dataHook","DataStructureHookByDataStructure","getOrCreate","DataStructureHook","forStructure","wrappingHook","PropertyWrappingHook","getOrCreateForProperty","HTMLElement","tagName","endsWith","mutationObserverHook","MutationObserverHook","getOrCreateForElement","eventBasedHook","EventBasedHook","FrameBasedHook","instance","disconnectAllForDependency","compKey","getLeftFor","keysFor","undefined","notifyAExprs","aexprs","getAExprsForDep","checkAndNotifyAExprs","isMemberDependency","isLocalDependency","object","self","getAsDependencyDescription","property","name","scope","Error","_depsToAExprs","dep","disconnectAllForAExpr","deps","getDepsForAExpr","removeAllLeftFor","forEach","from","getRightsFor","getLeftsFor","length","hasDepsForAExpr","clear","getAllLeft","_hooksToDeps","hook","remove","getDepsForHook","getHooksForDep","hasDepsForHook","hasHooksForDep","CompositeKeyToSourceCodeHook","WeakMap","PropertyWrappingHookByProperty","MutationObserverHookByHTMLElement","EventBasedHookByHTMLElement","Hook","installed","notifyDependencies","install","uninstall","getPrototypeDescriptors","obj","proto","prototype","descriptors","Object","getOwnPropertyDescriptors","entries","map","desc","wrapProperty","descriptor","after","defineProperty","assign","args","apply","call","monitorProperties","prototypeDescriptors","filter","addDescriptor","__compareAExprResults__","configurable","enumerable","getOwnPropertyDescriptor","get","set","element","_element","o","MutationObserver","mutations","observer","changeHappened","observe","attributes","attributeFilter","attributeOldValue","characterData","characterDataOldValue","childList","subtree","addEventListener","editor","on","_instance","initializeAe","x","ae","isMeta","onChange","RewritingActiveExpression","func","meta","strategy","new","target","addToRegistry","dispose","asAExpr","supportsDependencies","dependencies","DependencyAPI","sharedDependenciesWith","otherAExpr","ownDependencies","all","otherDependencies","own","shared","other","computeDiff","_aexpr","getDependencies","locals","dependency","members","globals","globalRef","global","currentAExpr","checkAndNotify","associateMember","prop","associateGlobal","globalName","associateLocal","varName","TracingHandler","memberUpdated","globalUpdated","localUpdated","reset","traceMember","getMember","getAndCallMember","setMember","val","setMemberAddition","setMemberSubtraction","setMemberMultiplication","setMemberDivision","setMemberRemainder","setMemberExponentiation","setMemberLeftShift","setMemberRightShift","setMemberUnsignedRightShift","setMemberBitwiseAND","setMemberBitwiseXOR","setMemberBitwiseOR","deleteMember","getLocal","setLocal","getGlobal","setGlobal"],"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 'src/client/reactive/utils/stack.js';\nimport CompositeKey from './composite-key.js';\nimport InjectiveMap from './injective-map.js';\nimport BidirectionalMultiMap from './bidirectional-multi-map.js';\nimport { using, isFunction } from 'utils';\n/*MD # Dependency Analysis MD*/\nlet expressionAnalysisMode = false;\nwindow.__expressionAnalysisMode__ = false;\n\nconst analysisModeManager = {\n  __enter__() {\n    expressionAnalysisMode = true;\n    window.__expressionAnalysisMode__ = expressionAnalysisMode;\n  },\n  __exit__() {\n    expressionAnalysisMode = !!aexprStack.top();\n    window.__expressionAnalysisMode__ = expressionAnalysisMode;\n  }\n}\nclass ExpressionAnalysis {\n  \n  static recalculateDependencies(aexpr) {\n    // #TODO: compute diff of Dependencies\n    DependencyManager.disconnectAllFor(aexpr);\n    this.check(aexpr);\n  }\n  \n  static check(aexpr) {\n    let value, isError;\n    using([analysisModeManager], () => {\n      // Do the function execution in ExpressionAnalysisMode\n      aexprStack.withElement(aexpr, () => {\n        const result = aexpr.evaluateToCurrentValue();\n        value = result.value\n        isError = result.isError\n      });\n    });\n  }\n\n}\n\nclass Dependency {\n  static getOrCreateFor(context, identifier, type) {\n    const key = ContextAndIdentifierCompositeKey.for(context, identifier);\n    return CompositeKeyToDependencies.getOrCreateRightFor(key, () => new Dependency(context, identifier, type));\n  }\n\n  // #TODO: compute and cache isGlobal\n  constructor(context, identifier, type) {\n    this._type = type;\n    \n    this.isTracked = false;\n  }\n\n  updateTracking() {\n    if (this.isTracked === DependenciesToAExprs.hasAExprsForDep(this)) { return; }\n    if (this.isTracked) {\n      this.untrack();\n    } else {\n      this.track();\n    }\n  }\n\n  track() {\n    this.isTracked = true;\n\n    const [context, identifier, value] = this.contextIdentifierValue();\n    const isGlobal = this.isGlobalDependency();\n\n    /*HTML <span style=\"font-weight: bold;\">Source Code Hook</span>: for anything <span style=\"color: green; font-weight: bold;\">members or locals</span> HTML*/\n    // always employ the source code hook\n    HooksToDependencies.associate(SourceCodeHook.getOrCreateFor(context, identifier), this);\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    var dataStructure;\n    if (this._type === 'member') {\n      dataStructure = context;\n    } else if(this._type === 'local') {\n      dataStructure = value;\n    }\n    if (dataStructure instanceof Array || dataStructure instanceof Set || dataStructure instanceof Map) {\n      const dataHook = DataStructureHookByDataStructure.getOrCreate(dataStructure, dataStructure => DataStructureHook.forStructure(dataStructure));\n      HooksToDependencies.associate(dataHook, this);\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      HooksToDependencies.associate(wrappingHook, this);\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 === 'KNOT-VIEW' && (identifier === 'knot' || identifier === 'knotLabel')) && !context.tagName.endsWith('-rp19')) {\n        // TODO: the member also influences what kind of observer we want to use!\n        const mutationObserverHook = MutationObserverHook.getOrCreateForElement(context);\n        HooksToDependencies.associate(mutationObserverHook, this);\n      }\n    }\n\n    /*HTML <span style=\"font-weight: bold;\">Event-based Change Hook</span>: handling <span style=\"color: green; font-weight: bold;\">HTMLElements</span> HTML*/\n    if (this._type === 'member' && context instanceof HTMLElement) {\n      const eventBasedHook = EventBasedHook.getOrCreateForElement(context);\n      // #TODO: we have to acknowledge that different properties require different events to listen on\n      //  e.g. code-mirror might have 'value' (so need to listen for 'change') or 'getCursor' (so need to listen for 'cursorActivity')\n      // eventBasedHook.listenFor(identifier);\n      HooksToDependencies.associate(eventBasedHook, this);\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      HooksToDependencies.associate(FrameBasedHook.instance, this);\n    }\n  }\n\n  untrack() {\n    this.isTracked = false;\n    HooksToDependencies.disconnectAllForDependency(this);\n  }\n\n  contextIdentifierValue() {\n    const compKey = CompositeKeyToDependencies.getLeftFor(this);\n    \n    const [context, identifier] = ContextAndIdentifierCompositeKey.keysFor(compKey);\n    const value = context !== undefined ? context[identifier] : undefined;\n    \n    return [context, identifier, value];\n  }\n\n  notifyAExprs() {\n    const aexprs = DependenciesToAExprs.getAExprsForDep(this);\n    DependencyManager.checkAndNotifyAExprs(aexprs);\n  }\n  \n  isMemberDependency() {\n    return this._type === 'member' && !this.isGlobal();\n  }\n  isGlobalDependency() {\n    return this._type === 'member' && this.isGlobal();\n  }\n  isLocalDependency() {\n    return this._type === 'local';\n  }\n  isGlobal() {\n    const compKey = CompositeKeyToDependencies.getLeftFor(this);\n    if (!compKey) {\n      return false;\n    }\n    const [object] = ContextAndIdentifierCompositeKey.keysFor(compKey);\n    return object === self;\n  }\n\n  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    } else if (this.isGlobalDependency()) {\n      return {\n        name: identifier,\n        value\n      };\n    } else if (this.isLocalDependency()) {\n      return {\n        scope: context,\n        name: identifier,\n        value\n      };\n    } else {\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    this._depsToAExprs.associate(dep, aexpr);\n    dep.updateTracking();\n  },\n\n  disconnectAllForAExpr(aexpr) {\n    const deps = this.getDepsForAExpr(aexpr);\n    this._depsToAExprs.removeAllLeftFor(aexpr);\n    deps.forEach(dep => dep.updateTracking());\n  },\n\n  getAExprsForDep(dep) {\n    return Array.from(this._depsToAExprs.getRightsFor(dep));\n  },\n  getDepsForAExpr(aexpr) {\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()\n      .forEach(dep => dep.updateTracking());\n  }\n};\n\nconst HooksToDependencies = {\n  _hooksToDeps: new BidirectionalMultiMap(),\n  \n  associate(hook, dep) {\n    this._hooksToDeps.associate(hook, dep);\n  },\n  remove(hook, dep) {\n    this._hooksToDeps.remove(hook, dep);\n  },\n  \n  disconnectAllForDependency(dep) {\n    this._hooksToDeps.removeAllLeftFor(dep);\n  },\n  \n  getDepsForHook(hook) {\n    return Array.from(this._hooksToDeps.getRightsFor(hook));\n  },\n  getHooksForDep(dep) {\n    return Array.from(this._hooksToDeps.getLeftsFor(dep));\n  },\n  \n  hasDepsForHook(hook) {\n    return this.getDepsForHook(hook).length >= 1;\n  },\n  hasHooksForDep(dep) {\n    return this.getHooksForDep(dep).length >= 1;\n  },\n  \n  /*\n   * Removes all associations.\n   */\n  clear() {\n    this._hooksToDeps.clear();\n  }\n};\n\n// 1. (obj, prop) or (scope, name) -> ContextAndIdentifierCompositeKey\n// - given via ContextAndIdentifierCompositeKey\nconst ContextAndIdentifierCompositeKey = new CompositeKey();\n\n// 2.1. ContextAndIdentifierCompositeKey 1<->1 Dependency\n// - CompositeKeyToDependencies\nconst CompositeKeyToDependencies = new InjectiveMap();\n// 2.2. Dependency *<->* AExpr\n// - DependenciesToAExprs\n\n/** Source Code Hooks */\n// 3.1. ContextAndIdentifierCompositeKey 1<->1 SourceCodeHook\n// - CompositeKeyToSourceCodeHook\nconst CompositeKeyToSourceCodeHook = new InjectiveMap();\n// 3.2. SourceCodeHook *<->* Dependency\n// - HooksToDependencies\n\n/** Data Structure Hooks */\n// 4.1 DataStructureHookByDataStructure\nconst DataStructureHookByDataStructure = new WeakMap(); // WeakMap<(Set/Array/Map), DataStructureHook>\n/** Wrapping Hooks */\n// 4.2 PropertyWrappingHookByProperty\nconst PropertyWrappingHookByProperty = new Map(); // Map<(String/Symbol), PropertyWrappingHook>\n/** Mutation Observer Hooks */\n// 4.3 DataStructureHookByDataStructure\nconst MutationObserverHookByHTMLElement = new WeakMap(); // WeakMap<HTMLElement, MutationObserverHook>\n/** XXX */\n// 4.4 XXX\nconst EventBasedHookByHTMLElement = new WeakMap(); // WeakMap<HTMLElement, EventBasedHook>\n\n\nclass Hook {\n  constructor() {\n    this.installed = false;\n  }\n  \n  notifyDependencies() {\n    HooksToDependencies.getDepsForHook(this).forEach(dep => dep.notifyAExprs())\n  }\n}\n\nclass SourceCodeHook extends Hook {\n  static getOrCreateFor(context, identifier) {\n    const compKey = ContextAndIdentifierCompositeKey.for(context, identifier);\n    return CompositeKeyToSourceCodeHook.getOrCreateRightFor(compKey, key => new SourceCodeHook());\n  }\n  \n  constructor(context, identifier) {\n    super();\n\n    this.context = context;\n    this.identifier = identifier;\n  }\n  \n  install() {}\n  uninstall() {}\n}\n\nclass DataStructureHook extends Hook {\n  static forStructure(dataStructure) {\n    const hook = new DataStructureHook();\n    \n    function getPrototypeDescriptors(obj) {\n      const proto = obj.constructor.prototype;\n\n      const descriptors = Object.getOwnPropertyDescriptors(proto);\n      return Object.entries(descriptors).map(([key, desc]) => (desc.key = key, desc))\n    }\n\n    function wrapProperty(obj, descriptor, after) {\n      Object.defineProperty(obj, descriptor.key, Object.assign({}, descriptor, {\n        value(...args) {\n          try {\n            return descriptor.value.apply(this, args);\n          } finally {\n            after.call(this, ...args)\n          }\n        }\n      }));\n    }\n\n    function monitorProperties(obj) {\n      const prototypeDescriptors = getPrototypeDescriptors(obj);\n      Object.entries(Object.getOwnPropertyDescriptors(obj)); // unused -> need for array\n\n      prototypeDescriptors\n        .filter(descriptor => descriptor.key !== 'constructor') // the property constructor needs to be a constructor if called (as in cloneDeep in lodash); We leave it out explicitly as the constructor does not change any state #TODO\n        .forEach(addDescriptor => {\n          // var addDescriptor = prototypeDescriptors.find(d => d.key === 'add')\n          if (addDescriptor.value) {\n            if (isFunction(addDescriptor.value)) {\n              wrapProperty(obj, addDescriptor, function() {\n                // #HACK #TODO we need an `withoutLayer` equivalent here\n                if (window.__compareAExprResults__) { return; }\n\n                this; // references the modified container\n                hook.notifyDependencies();\n              });\n            } else {\n              // console.warn(`Property ${addDescriptor.key} has a value that is not a function, but ${addDescriptor.value}.`)\n            }\n          } else {\n            // console.warn(`Property ${addDescriptor.key} has no value.`)\n          }\n        });\n    }\n\n    monitorProperties(dataStructure);\n    \n    // set.add = function add(...args) {\n    //   const result = Set.prototype.add.call(this, ...args);\n    //   hook.notifyDependencies();\n    //   return result;\n    // }\n    return hook;\n  }\n}\n\nclass PropertyWrappingHook extends Hook {\n  static getOrCreateForProperty(property) {\n    return PropertyWrappingHookByProperty.getOrCreate(property, () => new PropertyWrappingHook(property));\n  }\n  \n  constructor(property) {\n    super();\n\n    this.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\nclass MutationObserverHook extends Hook {\n  static getOrCreateForElement(element) {\n    return MutationObserverHookByHTMLElement.getOrCreate(element, () => new MutationObserverHook(element));\n  }\n  \n  constructor(element) {\n    super();\n\n    this._element = element;\n    \n    const o = new MutationObserver((mutations, observer) => {\n      // const mutationRecords = o.takeRecords();\n      // lively.notify(`mutation on ${this._element.tagName}; ${mutations\n      //               .filter(m => m.type === \"attributes\")\n      //               .map(m => m.attributeName).join(', ')}.`)\n      this.changeHappened();\n      // mutations.forEach(mutation => {\n      //   if(mutation.type == \"attributes\") {\n      //     lively.notify(\n      //       `${mutation.oldValue} -> ${mutation.target.getAttribute(mutation.attributeName)}`,\n      //       `attribute: ${mutation.attributeName}`\n      //     );\n      //   }\n      //   if(mutation.type == \"characterData\") {\n      //     lively.notify(\n      //       `${mutation.oldValue}}`,\n      //       `characterData`\n      //     );\n      //   }\n      //   if(mutation.type == \"childList\") {\n      //     lively.success(\n      //       `${mutation.addedNodes.length} added, ${mutation.removedNodes.length} removed`,\n      //       `childList`\n      //     );\n      //   }\n      // });\n    });\n\n    o.observe(this._element, {\n      attributes: true,\n      attributeFilter: undefined,\n      attributeOldValue: true,\n\n      characterData: true,\n      characterDataOldValue: true,\n\n      childList: true,\n\n      subtree: true,\n    });\n    \n    // o.disconnect();\n  }\n\n  changeHappened() {\n    this.notifyDependencies();\n  }\n}\n\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\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\n\nconst aexprStack = new Stack();\n\nexport class RewritingActiveExpression extends BaseActiveExpression {\n  constructor(func, ...args) {\n    super(func, ...args);\n    this.meta({ strategy: 'Rewriting' });\n    ExpressionAnalysis.recalculateDependencies(this);\n\n    if (new.target === RewritingActiveExpression) {\n      this.addToRegistry();\n    }\n  }\n\n  dispose() {\n    super.dispose();\n    DependencyManager.disconnectAllFor(this);\n  }\n  \n  asAExpr() {\n    return this;\n  }\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()\n      .filter(dependency => dependency.isLocalDependency())\n      .map(dependency => dependency.getAsDependencyDescription());\n  }\n\n  members() {\n    return this.getDependencies()\n      .filter(dependency => dependency.isMemberDependency())\n      .map(dependency => dependency.getAsDependencyDescription());\n  }\n\n  globals() {\n    return this.getDependencies()\n      .filter(dependency => dependency.isGlobalDependency())\n      .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\n  (typeof self !== \"undefined\" ? self : // web worker\n    global); // node.js\n\nclass DependencyManager {\n  static get currentAExpr() {\n    return aexprStack.top();\n  }\n  \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) {\n    aexprs.forEach(aexpr => {\n      ExpressionAnalysis.recalculateDependencies(aexpr);\n    });\n    aexprs.forEach(aexpr => aexpr.checkAndNotify());\n  }\n\n  /**\n   * **************************************************************\n   * ********************** associate *****************************\n   * **************************************************************\n   */\n  static associateMember(obj, prop) {\n    const dependency = Dependency.getOrCreateFor(obj, prop, 'member');\n    DependenciesToAExprs.associate(dependency, this.currentAExpr);\n  }\n\n  static associateGlobal(globalName) {\n    const dependency = Dependency.getOrCreateFor(globalRef, globalName, 'member');\n    DependenciesToAExprs.associate(dependency, this.currentAExpr);\n  }\n\n  static associateLocal(scope, varName) {\n    const dependency = Dependency.getOrCreateFor(scope, varName, 'local');\n    DependenciesToAExprs.associate(dependency, this.currentAExpr);\n  }\n\n}\n\nclass TracingHandler {\n\n  /**\n   * **************************************************************\n   * ********************** update ********************************\n   * **************************************************************\n   */\n  static memberUpdated(obj, prop) {\n    SourceCodeHook.getOrCreateFor(obj, prop).notifyDependencies();\n  }\n\n  static globalUpdated(globalName) {\n    SourceCodeHook.getOrCreateFor(globalRef, globalName).notifyDependencies();\n  }\n\n  static localUpdated(scope, varName) {\n    SourceCodeHook.getOrCreateFor(scope, varName).notifyDependencies();\n  }\n\n}\n\n/*\n * Disconnects all associations between active expressions and object properties\n * As a result no currently enable active expression will be notified again,\n * effectively removing them from the system.\n *\n * #TODO: Caution, this might break with some semantics, if we still have references to an aexpr!\n */\nexport function reset() {\n  ContextAndIdentifierCompositeKey.clear();\n\n  CompositeKeyToDependencies.clear();\n  DependenciesToAExprs.clear();\n\n  CompositeKeyToSourceCodeHook.clear();\n  HooksToDependencies.clear();\n}\n\n/*MD # Source Code Point Cuts MD*/\n/**\n * (C)RUD for member attributes\n */\nexport function traceMember(obj, prop) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n}\n\nexport function getMember(obj, prop) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n  const result = obj[prop];\n  return result;\n}\n\nexport function getAndCallMember(obj, prop, args = []) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateMember(obj, prop);\n  }\n  const result = obj[prop](...args);\n  return result;\n}\n\nexport function setMember(obj, prop, val) {\n  const result = obj[prop] = val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberAddition(obj, prop, val) {\n  const result = obj[prop] += val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberSubtraction(obj, prop, val) {\n  const result = obj[prop] -= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberMultiplication(obj, prop, val) {\n  const result = obj[prop] *= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberDivision(obj, prop, val) {\n  const result = obj[prop] /= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberRemainder(obj, prop, val) {\n  const result = obj[prop] %= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberExponentiation(obj, prop, val) {\n  const result = obj[prop] **= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberLeftShift(obj, prop, val) {\n  const result = obj[prop] <<= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberRightShift(obj, prop, val) {\n  const result = obj[prop] >>= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberUnsignedRightShift(obj, prop, val) {\n  const result = obj[prop] >>>= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberBitwiseAND(obj, prop, val) {\n  const result = obj[prop] &= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberBitwiseXOR(obj, prop, val) {\n  const result = obj[prop] ^= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function setMemberBitwiseOR(obj, prop, val) {\n  const result = obj[prop] |= val;\n  TracingHandler.memberUpdated(obj, prop);\n  return result;\n}\n\nexport function deleteMember(obj, prop) {\n  const result = delete obj[prop];\n  TracingHandler.memberUpdated(obj, prop);\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) {\n  scope[varName] = value;\n  TracingHandler.localUpdated(scope, varName);\n}\n\nexport function getGlobal(globalName) {\n  if (expressionAnalysisMode) {\n    DependencyManager.associateGlobal(globalName);\n  }\n}\n\nexport function setGlobal(globalName) {\n  TracingHandler.globalUpdated(globalName);\n}\n\nexport default aexpr;\n"]}