{"version":3,"sources":["https://lively-kernel.org/lively4/composed-offset/src/client/ContextJS/src/Layers.js"],"names":["EventTypes","Event","updateMember","self","HTMLElement","console","warn","Error","System","import","lively4url","then","mod","Config","ignoreDeprecatedProceed","log_layer_code","log","string","proceedStack","AllLayers","GlobalLayers","AsyncLayerStack","object_id_counter","withLogLayerCode","func","old","LayerObjectID","Symbol","getLayerDefinitionForObject","layer","object","result","prototype","e","error","PartialLayer","constructor","layeredObject","layeredProperties","setLayeredPropertyValue","name","value","defineGetter","propertyName","getter","Object","defineProperty","get","configurable","defineSetter","setter","set","getterMethod","desc","getOwnPropertyDescriptor","setterMethod","property","hasOwnProperty","reinstall","getOwnPropertyNames","forEach","eachProperty","makePropertyLayerAware","makeFunctionLayerAware","ensurePartialLayer","enumerable","writable","layerMethod","displayName","String","type","isHidden","layerGetterMethod","layerSetterMethod","layerProperty","defs","defProperty","layerPropertyWithShadow","layeredPropSymbol","layeredGetter","undefined","proceed","layeredSetter","v","computeLayersFor","obj","activeLayers","composeLayers","stack","slice","i","length","current","withLayers","filter","l","includes","concat","withoutLayers","LayerStack","resetLayerStack","isStatic","toString","composition","invalidateLayerComposition","currentLayers","ea","lookupLayeredFunctionForObject","function_name","methodType","n","partialFunction","partialLayerForObject","superclass","getPrototypeOf","pvtMakeFunctionOrPropertyLayerAware","slotName","baseValue","isLayerAware","makeSlotLayerAwareWithNormalLookup","tmpObj","wrapped_function","PartialLayerComposition","push","invokeLayeredMethodThenPopProceedStack","apply","arguments","isContextJSWrapper","getOriginal","originalFunction","newFunction","pop","base_obj","base_function","baseObj","baseObjProperty","propName","makeFunctionLayerUnaware","prevFunction","currentFunction","Function","uninstallLayersInObject","globalContextForNamedLayers","enableLayer","indexOf","wasAlreadyActive","_emitActivateCallbacks","disableLayer","idx","_emitDeactivateCallbacks","splice","args","partialMethodIndex","partialMethods","index","partialMethod","COPError","invokeNextPartialMethod","Layer","context","_name","_context","_activateCallbacks","_deactivateCallbacks","events","logEvent","LAYERCREATED","fullName","layeredObjects","map","partialLayers","prop","layeredClasses","remove","isGlobal","beNotGlobal","implicitLayers","delete","AExprForILA","dispose","uninstall","eachLayeredObj","refineClass","classObject","methods","debugInfo","refineObject","code","location","lively","addRefineEvent","unrefineObject","id","unrefineClass","classObj","reinstallInClass","reinstallInObject","partialLayer","findLast","array","predicate","x","getILAChangeLocation","lastChangeEvent","event","CHANGED","ensureResolved","triggers","beGlobal","PL","fn","hide","isLayer","onActivate","callback","_fallbackToReactiveTrackingOfILA","onDeactivate","cb","functions","REFINE","addUnrefineEvent","UNREFINE","eventType","markTimestamp","reason","CUSTOM","activeWhile","condition","aexprConstructor","implicitlyActivated","add","_shouldUseReactiveTracking","_setupReactiveILA","onBecomeTrue","onBecomeFalse","setAE","clearActiveWhile","mightBeActive","Set","getActiveImplicitLayers","collectWithLayersIn","layers","unshift","collectWithoutLayersIn","structuralLayers","owner","aysncLayers","j","globalLayers","dynamicLayers","activeImplicitLayers","getImplicitLayers","allLayersFor","functionName","allLayers","LayerableObjectTrait","defaultActiveLayersFunc","setWithLayers","addWithLayer","getWithLayers","removeWithLayer","addWithoutLayer","getWithoutLayers","include","setWithoutLayers","removeWithoutLayer","getWithoutLayer","LayerableObject","message","_msg","baseFunction","_partialMethods","_layers","_object"],"mappings":"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","file":"Layers.js","sourcesContent":["/*\n * Copyright (c) 2008-2016 Hasso Plattner Institute\n *\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n/* \n * Private Helpers for Development\n */\nimport { EventTypes } from 'src/client/reactive/active-expression/events/event.js';\nimport Event from 'src/client/reactive/active-expression/events/event.js';\n// import { updateMember } from 'src/client/reactive/active-expression-rewriting/active-expression-rewriting.js';\n\n\n// #HACK ActiveExpression rewriting needs lively4 and lang.js \nvar updateMember; \nif (self.HTMLElement) {\n  updateMember =  function() {\n    console.warn(\"Layers.js: aexpr updateMember not loaed yet!\")\n    throw new Error(\"raise condition? active-expression-rewriting.js not loaded yet\")\n  }\n  System.import(lively4url + '/src/client/reactive/active-expression-rewriting/active-expression-rewriting.js').then(mod => {\n    updateMember = mod.updateMember // replace updateMember\n  })\n} else {\n  // fallback for worker or nodejs \n  updateMember =  function() {\n    // there is nothing to do here? \n  }  \n}\n\nexport const Config = {};\nConfig.ignoreDeprecatedProceed = true;\n\nexport let log_layer_code = false;\nexport function log(string) {\n  if (log_layer_code) console.log(string);\n}\n\n/* \n * Private State\n */\n\n// #HACK #TODO\nself.proceedStack = [];\nself.AllLayers = [];\nself.GlobalLayers = [];\nself.AsyncLayerStack = [];\n\n// export const proceedStack = [];\n// export const GlobalLayers = [];\n\n// hack, to work around absence of identity dictionaries in JavaScript\n// we could perhaps limit ourselfs to layer only those objects that respond to object.id()\n// because working with objects is a serialization problem in itself, perhaps we should\n// restrict ourself in working with classes\n// So classes have names and names can be used as keys in dictionaries :-)\nlet object_id_counter = 0;\n\n/* \n * Private Methods\n */\n\n// for debugging ContextJS itself\nexport function withLogLayerCode(func) {\n  try {\n    var old = log_layer_code;\n    log_layer_code = true;\n    func();\n  } finally {\n    log_layer_code = old;\n  }\n}\n\nconst LayerObjectID = self.Symbol(\"layerObjectID\");\n\nexport function getLayerDefinitionForObject(layer, object) {\n  // log(\"cop getLayerDefinitionForObject(\" + layer + \", \" + object + \")\");\n  if (!layer || !object) {\n    return;\n  }\n  var result = layer[object[LayerObjectID]];\n  // #BUG Maximum call stack size exceeded\n  try {\n    return result ? result : getLayerDefinitionForObject(layer, object.prototype);\n  } catch (e) {\n    debugger;\n    console.error('getLayerDefinitionForObject', e);\n    return;\n  }\n}\n\n/**\n * Stores partial definitions for a single layered object and layer.\n */\nclass PartialLayer {\n  constructor(layeredObject) {\n    this.layeredObject = layeredObject;\n    this.layeredProperties = {};\n  }\n\n  setLayeredPropertyValue(name, value) {\n    this.layeredProperties[name] = value;\n  }\n\n  defineGetter(propertyName, getter) {\n    return Object.defineProperty(this.layeredProperties, propertyName, { get: getter, configurable: true });\n  }\n\n  defineSetter(propertyName, setter) {\n    return Object.defineProperty(this.layeredProperties, propertyName, { set: setter, configurable: true });\n  }\n\n  getterMethod(propertyName) {\n    var desc = Object.getOwnPropertyDescriptor(this.layeredProperties, propertyName);\n    if (desc) return desc.get;\n  }\n\n  setterMethod(propertyName) {\n    var desc = Object.getOwnPropertyDescriptor(this.layeredProperties, propertyName);\n    if (desc) return desc.set;\n  }\n\n  property(propertyName) {\n    if (this.layeredProperties.hasOwnProperty(propertyName)) {\n      return this.layeredProperties[propertyName];\n    }\n  }\n\n  reinstall() {\n    Object.getOwnPropertyNames(this.layeredProperties).forEach(eachProperty => {\n      const property = Object.getOwnPropertyDescriptor(this.layeredProperties, eachProperty);\n      if (typeof property.get !== 'undefined' || typeof property.set !== 'undefined') {\n        makePropertyLayerAware(this.layeredObject, eachProperty);\n      } else {\n        makeFunctionLayerAware(this.layeredObject, eachProperty);\n      }\n    });\n  }\n}\n\nexport function ensurePartialLayer(layer, object) {\n  if (!layer) {\n    throw new Error(\"in ensurePartialLayer: layer is nil\");\n  }\n  if (!object.hasOwnProperty(LayerObjectID)) {\n    Object.defineProperty(object, LayerObjectID, {\n      value: object_id_counter++,\n      enumerable: false,\n      configurable: false,\n      writable: false\n    });\n  }\n  if (!layer[object[LayerObjectID]]) {\n    layer[object[LayerObjectID]] = new PartialLayer(object);\n  }\n  return layer[object[LayerObjectID]];\n}\n\n// TODO(mariannet) : Find out if ES6 constructor also has type\nexport function layerMethod(layer, object, property, func) {\n  ensurePartialLayer(layer, object).setLayeredPropertyValue(property, func);\n  func.displayName = \"layered \" + String(layer.name) + \" \" + (object.constructor ? object.constructor.type + \"$\" : \"\") + property;\n  makeFunctionLayerAware(object, property, layer.isHidden);\n\n  // Bookkeeping for layer uninstall\n  // typeof object.getName === 'function'\n  //    && (layer._layeredFunctionsList[object][property] = true);\n}\n\nfunction layerGetterMethod(layer, object, property, getter) {\n  ensurePartialLayer(layer, object).defineGetter(property, getter);\n}\n\nfunction layerSetterMethod(layer, object, property, setter) {\n  ensurePartialLayer(layer, object).defineSetter(property, setter);\n}\n\nexport function layerProperty(layer, object, property, defs) {\n  var defProperty = Object.getOwnPropertyDescriptor(defs, property);\n  var getter = defProperty && defProperty.get;\n  if (getter) {\n    layerGetterMethod(layer, object, property, getter);\n  }\n  var setter = defProperty && defProperty.set;\n  if (setter) {\n    layerSetterMethod(layer, object, property, setter);\n  }\n  if (getter || setter) {\n    makePropertyLayerAware(object, property);\n  } else {\n    layerMethod(layer, object, property, defs[property]);\n  }\n}\n\nexport function layerPropertyWithShadow(layer, object, property) {\n  // shadowing does not work with current implementation\n  // see the shadow tests in LayersTest\n  // TODO: the tests are green, what is the above comment about?\n  var defs = {};\n  // var baseValue = object[property];\n  const layeredPropSymbol = self.Symbol(property + ' ' + (typeof layer.name === 'string' ? 'for Layer ' + layer.name : 'for anonymous Layer'));\n  Object.defineProperty(defs, property, {\n    get: function layeredGetter() {\n      return this[layeredPropSymbol] === undefined ? proceed() : this[layeredPropSymbol];\n    },\n    set: function layeredSetter(v) {\n      this[layeredPropSymbol] = v;\n    },\n    configurable: true\n  });\n  layerProperty(layer, object, property, defs);\n}\n\nexport function computeLayersFor(obj) {\n  return obj && obj.activeLayers ? obj.activeLayers(activeLayers) : activeLayers();\n}\n\nexport function composeLayers(stack) {\n  var result = self.GlobalLayers.slice(0); // copy the array, #TODO: use `Array.from`\n  // duplicate of dynamicLayers, #TODO: use LayerableObjectTrait.dynamicLayers\n  for (var i = 0; i < stack.length; i++) {\n    var current = stack[i];\n    if (current.withLayers) {\n      result = result.filter(l => !current.withLayers.includes(l)).concat(current.withLayers);\n    } else if (current.withoutLayers) {\n      result = result.filter(l => !current.withoutLayers.includes(l));\n    }\n  }\n  return result;\n}\n\nexport let LayerStack;\n\nexport function resetLayerStack() {\n  LayerStack = [{\n    isStatic: true,\n    toString: function () {\n      return \"BaseLayer\";\n    },\n    composition: null\n  }];\n  invalidateLayerComposition();\n}\n\nexport function currentLayers() {\n  return activeLayers\n  // if (LayerStack.length == 0) {\n  //   throw new Error(\"The default layer is missing\");\n  // }\n  // // NON OPTIMIZED VERSION FOR STATE BASED LAYER ACTIVATION \n  // // #TODO check if this still hold for #async\n  // var current = LayerStack[LayerStack.length - 1];\n  // if (!current.composition) {\n  //   current.composition = composeLayers(LayerStack) ;\n  // }\n  // return current.composition.concat(getActiveImplicitLayers());\n  ();\n}\n\n// clear cached layer compositions\nexport function invalidateLayerComposition() {\n  LayerStack.forEach(function (ea) {\n    ea.composition = null;\n  });\n}\n\nexport function lookupLayeredFunctionForObject(self, layer, function_name, methodType, n) {\n  if (!layer) {\n    return undefined;\n  }\n  let partialFunction;\n  const partialLayerForObject = getLayerDefinitionForObject(layer, self);\n  if (partialLayerForObject) {\n    // log(\"  found layer definitions for object\");\n    if (methodType == 'getter') {\n      partialFunction = partialLayerForObject.getterMethod(function_name);\n    } else if (methodType == 'setter') {\n      partialFunction = partialLayerForObject.setterMethod(function_name);\n    } else {\n      partialFunction = partialLayerForObject.property(function_name);\n    }\n  }\n  if (!partialFunction && !self.hasOwnProperty(function_name)) {\n    // this method was probably added by a layer\n    // so try to look it up in the superclass hierachy\n    const superclass = Object.getPrototypeOf(self);\n    if (superclass) {\n      return lookupLayeredFunctionForObject(superclass, layer, function_name, methodType);\n    }\n  }\n  return partialFunction;\n}\n\nfunction pvtMakeFunctionOrPropertyLayerAware(obj, slotName, baseValue, type, isHidden) {\n  // install in obj[slotName] a cop wrapper that weaves partial methods\n  // into real method (baseValue)\n  if (baseValue.isLayerAware) {\n    return;\n  }\n  makeSlotLayerAwareWithNormalLookup(obj, slotName, baseValue, type, isHidden);\n}\n\nfunction makeSlotLayerAwareWithNormalLookup(obj, slotName, baseValue, type, isHidden) {\n  var tmpObj = {};\n  if (baseValue && baseValue.isLayerAware) {\n    debugger;\n  }\n  let wrapped_function = function () {\n    'use strict';\n\n    var composition = new PartialLayerComposition(this, slotName, baseValue, type);\n    self.proceedStack.push(composition);\n    return invokeLayeredMethodThenPopProceedStack.apply(this, arguments);\n  };\n  wrapped_function.displayName = \"wrapped_\" + slotName;\n  wrapped_function.isLayerAware = true;\n  // this is more declarative outside of COP context\n  wrapped_function.isContextJSWrapper = true;\n  if (isHidden) {\n    wrapped_function.toString = function () {\n      return this.getOriginal().toString();\n    };\n  }\n  // For wrapped_function.getOriginal()\n  wrapped_function.originalFunction = baseValue;\n  if (type == \"getter\") {\n    Object.defineProperty(obj, slotName, { get: wrapped_function });\n  } else if (type == \"setter\") {\n    Object.defineProperty(obj, slotName, { set: wrapped_function });\n  } else {\n    Object.defineProperty(obj, slotName, {\n      get() {\n        return wrapped_function;\n      },\n      set(newFunction) {\n        if (newFunction.isLayerAware) {\n          // when someone reasigns an already layered method.... Example Bug. Dexie modifies Promise.then\n          // #Paper #ContextJS \n        } else {\n          makeSlotLayerAwareWithNormalLookup(this, slotName, newFunction);\n        }\n      }\n    });\n  }\n}\n\nfunction invokeLayeredMethodThenPopProceedStack() {\n  'use strict';\n\n  try {\n    return proceed.apply(void 0 /* undefined */, arguments);\n  } finally {\n    self.proceedStack.pop();\n  }\n}\n\nfunction makeFunctionLayerAware(base_obj, function_name, isHidden) {\n  if (!base_obj) {\n    throw new Error(\"can't layer an non existent object\");\n  }\n  /* ensure base function */\n  var base_function = base_obj[function_name];\n  if (!base_function) {\n    // console.log(\"WARNING can't layer an non existent function\" + function_name +\n    // \" , so do nothing\")\n    // return;\n    base_function = () => null;\n  }\n  pvtMakeFunctionOrPropertyLayerAware(base_obj, function_name, base_function, undefined, isHidden);\n}\n\nfunction makePropertyLayerAware(baseObj, property) {\n  if (!baseObj) {\n    throw new Error(\"can't layer a non existent object\");\n  }\n  // ensure base getter and setter\n  var baseObjProperty = Object.getOwnPropertyDescriptor(baseObj, property);\n  var propName = \"__layered_\" + property + \"__\";\n  var getter = baseObjProperty && baseObjProperty.get;\n  if (!getter) {\n    // does not work when dealing with classes and instances...\n    baseObj[propName] = baseObj[property]; // take over old value\n    getter = function () {\n      return this[propName];\n    };\n    Object.defineProperty(baseObj, property, { get: getter, configurable: true });\n  }\n  var setter = baseObjProperty && baseObjProperty.set;\n  if (!setter) {\n    setter = function (value) {\n      return this[propName] = value;\n    };\n    Object.defineProperty(baseObj, property, { set: setter, configurable: true });\n  }\n  pvtMakeFunctionOrPropertyLayerAware(baseObj, property, getter, 'getter');\n  pvtMakeFunctionOrPropertyLayerAware(baseObj, property, setter, 'setter');\n}\n\nfunction makeFunctionLayerUnaware(base_obj, function_name) {\n  if (!base_obj) {\n    throw new Error(\"need object to makeFunctionLayerUnaware\");\n  }\n  var prevFunction;\n  var currentFunction = base_obj[function_name];\n  if (currentFunction === undefined) {\n    return; // nothing to do here\n  }\n  while (typeof currentFunction.originalFunction == 'function' && !currentFunction.isLayerAware) {\n    prevFunction = currentFunction;\n    currentFunction = currentFunction.originalFunction;\n  }\n  if (!currentFunction.isLayerAware) {\n    return; // nothing to do here\n  }\n  var originalFunction = currentFunction.originalFunction;\n  if (!(originalFunction instanceof Function)) {\n    throw new Error(\"makeFunctionLayerUnaware Error: no orignal function\");\n  }\n  if (prevFunction instanceof Function) {\n    prevFunction.originalFunction = originalFunction;\n  } else {\n    // need to use defineProperty because the setter keeps the function wrapped\n    Object.defineProperty(base_obj, function_name, {\n      value: originalFunction,\n      configurable: true\n    });\n  }\n}\n\nexport function uninstallLayersInObject(object) {\n  Object.getOwnPropertyNames(object).forEach(ea => {\n    if (typeof object[ea] === 'function') makeFunctionLayerUnaware(object, ea);\n  });\n}\n\n/* \n * PUBLIC COP Layer Definition\n */\n\nvar globalContextForNamedLayers = {};\n\nexport { globalContextForNamedLayers as GlobalNamedLayers };\n\n// Gloabl Layer Activation\nexport function enableLayer(layer) {\n  if (self.GlobalLayers.indexOf(layer) !== -1) {\n    return;\n  }\n  const wasAlreadyActive = currentLayers().includes(layer);\n  self.GlobalLayers.push(layer);\n  invalidateLayerComposition();\n  if (!wasAlreadyActive) {\n    layer._emitActivateCallbacks();\n  }\n}\n\nexport function disableLayer(layer) {\n  var idx = self.GlobalLayers.indexOf(layer);\n  if (idx < 0) {\n    return;\n  }\n  layer._emitDeactivateCallbacks();\n  self.GlobalLayers.splice(idx, 1);\n  invalidateLayerComposition();\n}\n\nexport function proceed(...args) {\n  // COP Proceed Function\n  var composition = self.proceedStack[self.proceedStack.length - 1];\n  if (!composition) {\n    console.warn('ContextJS: no composition to proceed (stack is empty) ');\n    return;\n  }\n  if (composition.partialMethodIndex == undefined) {\n    composition.partialMethodIndex = composition.partialMethods.length - 1;\n  }\n  var index = composition.partialMethodIndex;\n  var partialMethod = composition.partialMethods[index];\n  if (!partialMethod) {\n    if (!partialMethod) {\n      throw new COPError('no partialMethod to proceed');\n    }\n  } else {\n    composition.partialMethodIndex = index - 1;\n    try {\n      if (self.proceedStack.length > 1000) {\n        debugger; // #Debug\n      }\n\n      return invokeNextPartialMethod(partialMethod, index, composition, args);\n    } catch (e) {\n      console.error(\"proceed \" + self.proceedStack.length, e);\n      debugger; // #TODO debug endless recursion!\n      return;\n    }\n  }\n}\n\nfunction invokeNextPartialMethod(partialMethod, index, composition, args) {\n  try {\n    return partialMethod.apply(composition.object, args);\n  } finally {\n    composition.partialMethodIndex = index;\n  }\n}\n\n/* \n * Layer Class\n */\nexport class Layer {\n  constructor(name, context) {\n    this._name = name;\n    if (typeof name === 'undefined') {\n      this._name = self.Symbol('COP Layer');\n    }\n    this._context = context;\n    // this._layeredFunctionsList = {};\n\n    this._activateCallbacks = [];\n    this._deactivateCallbacks = [];\n    this.events = [];\n    this.logEvent(EventTypes.LAYERCREATED, { layer: this });\n    self.AllLayers.push(this);\n  }\n\n  // Accessing\n  get name() {\n    return this._name;\n  }\n  fullName() {\n    return '' + this._context + '.' + this._name;\n  }\n  layeredObjects() {\n    return Object.getOwnPropertyNames(this).map(ea => this[ea] && this[ea].layeredObject).filter(ea => ea); // filters falsy things\n  }\n  partialLayers() {\n    return Object.getOwnPropertyNames(this).map(propName => this[propName]).filter(prop => prop && prop.layeredObject);\n  }\n  // TODO: doesn't differentiate between functions and classes - necessary?\n  layeredClasses() {\n    return this.layeredObjects().map(ea => ea.constructor);\n  }\n\n  // Removing\n  remove() {\n\n    self.AllLayers.splice(self.AllLayers.indexOf(this), 1);\n    // Deletes the LayerClass, but keeps the layered Functions.\n    if (this.isGlobal()) {\n      this.beNotGlobal();\n    }\n    implicitLayers.delete(this);\n    if (this.AExprForILA) {\n      this.AExprForILA.dispose();\n    }\n\n    var context = this._context;\n    if (typeof context !== 'undefined') delete context[this.name];\n  }\n  uninstall() {\n    // Uninstalls just this Layer.\n    // functions that are layered by other Layers will not be reset.\n    var layer = this;\n    this.layeredObjects().forEach(function (eachLayeredObj) {\n      // var layerIdx = typeof eachLayeredObj.activeLayers === 'function'\n      //     ? eachLayeredObj.activeLayers().indexOf(layer) : -1;\n\n      // #Special Lively Webwerkstatt code.... General Case? #Jens\n      // #TODO if we have of gloabal list of all layers... we can look there\n\n      // Properties.own(layer._layeredFunctionsList[eachLayeredObj]).each(\n      //   function(eachLayeredFunc) {\n      //     var newerLayer = eachLayeredObj.activeLayers().find(\n      //       function(eachOtherLayer) {\n      //         var eachOtherLayerIdx\n      //             = eachLayeredObj.activeLayers().indexOf(eachOtherLayer);\n      //         var isNewer = (eachOtherLayerIdx !== -1)\n      //             && (eachOtherLayerIdx < layerIdx);\n      //         return isNewer &&\n      //             eachOtherLayer._layeredFunctionsList[eachLayeredObj][eachLayeredFunc];\n      //       });\n      //       if (!newerLayer) {\n      //         makeFunctionLayerUnaware(eachLayeredObj, eachLayeredFunc);\n      //       }\n      //   });\n    });\n    this.remove();\n  }\n\n  // Layer installation\n  refineClass(classObject, methods, debugInfo) {\n    if (!classObject || !classObject.prototype) {\n      throw new Error(\"ContextJS: can not refine class '\" + classObject + \"' in \" + this);\n    }\n    this.refineObject(classObject.prototype, methods, debugInfo);\n    return this;\n  }\n\n  // Layering objects may be a garbage collection problem, because the layers keep strong\n  // reference to the objects\n  refineObject(object, methods, debugInfo) {\n    // log(\"cop refineObject\");\n\n    // Bookkeeping:\n    // typeof object.getName === 'function' && (layer._layeredFunctionsList[object] = {});\n    Object.getOwnPropertyNames(methods).forEach(function_name => {\n      if (debugInfo) {\n        console.log(\"ContextJS DEBUG INFO \", debugInfo)\n        if (methods[function_name] instanceof Function) {\n          methods[function_name].code = debugInfo[function_name].code;\n          methods[function_name].location = debugInfo[function_name].location;\n        } else {\n          lively.warn(\"Unable to add debug info to non-function property\");\n        }\n      }\n      // log(\" layer property: \" + function_name)\n      layerProperty(this, object, function_name, methods);\n    });\n    this.addRefineEvent(object, methods, debugInfo);\n    return this;\n  }\n  unrefineObject(obj) {\n    var id = obj[LayerObjectID];\n    if (id !== undefined) {\n      delete this[id];\n    }\n  }\n  unrefineClass(classObj) {\n    this.unrefineObject(classObj.prototype);\n  }\n\n  reinstallInClass(constructor) {\n    this.reinstallInObject(constructor.prototype);\n  }\n\n  reinstallInObject(object) {\n    const partialLayer = ensurePartialLayer(this, object);\n    partialLayer.reinstall();\n  }\n  \n  findLast(array, predicate) {\n    for (let i = array.length - 1; i >= 0; --i) {\n      const x = array[i];\n      if (predicate(x)) {\n        return x;\n      }\n    }\n  }  \n  \n  async getILAChangeLocation() {\n    if(this.AExprForILA) {\n      const lastChangeEvent = this.findLast(this.AExprForILA.events, event => event.type === EventTypes.CHANGED);\n      if (!lastChangeEvent) {\n        return undefined\n      }\n      await lastChangeEvent.ensureResolved();\n      if(lastChangeEvent.value && lastChangeEvent.value.triggers && lastChangeEvent.value.triggers.length > 0) {\n        return lastChangeEvent.value.triggers[0].location;\n      }\n    }\n    return undefined;\n  }\n\n  // Layer activation\n  beGlobal() {\n    enableLayer(this);\n    this.getILAChangeLocation().then(location => {\n      if (!location) return;\n      for(const PL of this.partialLayers()) {\n        Object.getOwnPropertyNames(PL.layeredProperties).forEach(fn => {\n            updateMember(PL.layeredObject, fn, location);\n        })\n      }         \n    });\n    return this;\n  }\n  beNotGlobal() {\n    disableLayer(this);\n    this.getILAChangeLocation().then(location => {\n      if (!location) return;\n      for(const PL of this.partialLayers()) {\n        Object.getOwnPropertyNames(PL.layeredProperties).forEach(fn => {\n            updateMember(PL.layeredObject, fn, location);\n        })\n      }    \n    });\n    return this;\n  }\n  hide() {\n    // Hidden Layers do not appear when evaluating the sourcecode of a function\n    // TODO: this function has to be called BEFORE the layer refines any class,\n    // due to problems in unrefining classes.\n    this.isHidden = true;\n    return this;\n  }\n\n  // Testing\n  isLayer() {\n    return true;\n  }\n  isGlobal() {\n    return self.GlobalLayers.indexOf(this) !== -1;\n  }\n\n  // Debugging\n  toString() {\n    return String(this.name); // could be a symbol\n  }\n\n  // Life-cycle callbacks\n  onActivate(callback) {\n    this._activateCallbacks.push(callback);\n    this._fallbackToReactiveTrackingOfILA();\n    return this;\n  }\n  onDeactivate(callback) {\n    this._deactivateCallbacks.push(callback);\n    this._fallbackToReactiveTrackingOfILA();\n    return this;\n  }\n  _emitActivateCallbacks() {\n    this._activateCallbacks.forEach(cb => cb());\n  }\n  _emitDeactivateCallbacks() {\n    this._deactivateCallbacks.forEach(cb => cb());\n  }\n\n  addRefineEvent(obj, functions, debugInfo) {\n    this.logEvent(EventTypes.REFINE, { obj, functions, debugInfo })\n  }\n\n  addUnrefineEvent(obj) {\n    this.logEvent(EventTypes.UNREFINE, {obj})\n  }\n\n  logEvent(eventType, obj) {\n    if (this.AExprForILA) {\n      this.AExprForILA.logEvent(eventType, obj);\n    } else {\n      this.events.push(new Event(undefined, obj, eventType));\n    }\n  }\n\n  markTimestamp(reason) {\n    this.logEvent(EventTypes.CUSTOM, reason);\n  }\n\n  // Implicit Layer Activation\n  activeWhile(condition, aexprConstructor) {\n    this.implicitlyActivated = condition;\n    this.aexprConstructor = aexprConstructor;\n\n    implicitLayers.add(this);\n    this._fallbackToReactiveTrackingOfILA();\n\n    return this;\n  }\n  _fallbackToReactiveTrackingOfILA() {\n    if (this._shouldUseReactiveTracking()) {\n      this._setupReactiveILA();\n    }\n  }\n  _shouldUseReactiveTracking() {\n    return this.implicitlyActivated && this.aexprConstructor && this._activateCallbacks.length + this._deactivateCallbacks.length > 0;\n  }\n  _setupReactiveILA() {\n    implicitLayers.delete(this);\n\n    if (!this.AExprForILA) {\n      this.AExprForILA = this.aexprConstructor(this.implicitlyActivated, this).onBecomeTrue(() => this.beGlobal()).onBecomeFalse(() => this.beNotGlobal());\n      this.events.forEach(event => {\n        event.setAE(this.AExprForILA);\n      });\n    }\n  }\n  \n  clearActiveWhile() {\n    const mightBeActive = !!this.AExprForILA;\n    if (mightBeActive) {\n      this.AExprForILA.dispose()\n    }\n    delete this.aexprConstructor\n\n    implicitLayers.delete(this);\n    delete this.implicitlyActivated\n    \n    if (mightBeActive) {\n      this.beNotGlobal()\n    }\n  }\n\n}\n\nconst implicitLayers = new Set();\nfunction getActiveImplicitLayers() {\n  return [...implicitLayers].filter(layer => layer.implicitlyActivated());\n}\n\nexport function collectWithLayersIn(layers, result) {\n  for (var i = layers.length - 1; i >= 0; i--) {\n    var ea = layers[i];\n    if (result.withLayers.indexOf(ea) === -1 && result.withoutLayers.indexOf(ea) === -1) {\n      result.withLayers.unshift(ea);\n    }\n  }\n}\n\nexport function collectWithoutLayersIn(layers, result) {\n  for (var i = 0; i < layers.length; i++) {\n    var ea = layers[i];\n    if (result.withoutLayers.indexOf(ea) === -1) {\n      result.withoutLayers.push(ea);\n    }\n  }\n}\n\nexport function structuralLayers(result, obj) {\n  // var allLayers = result.withLayers;\n  // var allWithoutLayers = result.withoutLayers;\n  // go ownerchain backward and gather all layer activations and deactivations\n  while (obj) {\n    // don't use accessor methods because of speed... (not measured yet)\n    if (obj.withLayers) {\n      collectWithLayersIn(obj.withLayers, result);\n    }\n    if (obj.withoutLayers) {\n      collectWithoutLayersIn(obj.withoutLayers, result);\n    }\n    // recurse, stop if owner is undefined\n    obj = obj.owner; // || obj.parentElement || obj.parentNode\n  }\n  return result;\n}\n\nexport function aysncLayers(result) {\n  // optimized version, that does not use closures and recursion\n  var stack = self.AsyncLayerStack;\n  // top down, ignore bottom element\n  for (var j = stack.length - 1; j > 0; j--) {\n    var current = stack[j];\n    if (current.withLayers) {\n      collectWithLayersIn(current.withLayers, result);\n    }\n    if (current.withoutLayers) {\n      collectWithoutLayersIn(current.withoutLayers, result);\n    }\n  }\n  return result;\n}\n\nexport function globalLayers(result) {\n  collectWithLayersIn(self.GlobalLayers, result);\n  return result;\n}\n\nexport function dynamicLayers(result) {\n  // optimized version, that does not use closures and recursion\n  var stack = LayerStack;\n  // top down, ignore bottom element\n  for (var j = stack.length - 1; j > 0; j--) {\n    var current = stack[j];\n    if (current.withLayers) {\n      collectWithLayersIn(current.withLayers, result);\n    }\n    if (current.withoutLayers) {\n      collectWithoutLayersIn(current.withoutLayers, result);\n    }\n  }\n  return result;\n}\n\n// #TODO #STEFAN rename -> implicitLayers\nexport function activeImplicitLayers(result) {\n  collectWithLayersIn(getActiveImplicitLayers(), result);\n  return result;\n}\n\nexport function getImplicitLayers(result) {\n  [...implicitLayers].forEach(layer => {\n    if (layer.implicitlyActivated()) {\n      collectWithLayersIn([layer], result);\n    } else {\n      collectWithoutLayersIn([layer], result);\n    }\n  });\n  return result;\n}\n\nexport function allLayersFor(obj, functionName, methodType) {\n  const result = [];\n  const layers = self.AllLayers;\n  for (var i = 0; i < layers.length; i++) {\n    var layer = layers[i];\n    var partialMethod = lookupLayeredFunctionForObject(obj, layer, functionName, methodType);\n    if (partialMethod) {\n      result.push({ partialMethod, layer });\n    }\n  }\n  return result;\n}\n\nexport function allLayers() {\n  var result = { withLayers: [], withoutLayers: [] };\n  dynamicLayers(result);\n\n  getImplicitLayers(result);\n\n  globalLayers(result);\n\n  return result;\n}\n\nexport function activeLayers() {\n  var result = { withLayers: [], withoutLayers: [] };\n  // go top to bottom in stack... \n  // so the last (dynamically) (de-)activated layers are first...\n  // remember withLayers and withoutLayers in result\n  // this is a bit to \"clever\" to iterate only once...\n  dynamicLayers(result);\n\n  // #Idea we can implement structural layer for HTMLElements without having to modify prototype...\n  // structuralLayers(result, obj);\n  activeImplicitLayers(result);\n\n  globalLayers(result);\n  // and the global layers are last\n  return result.withLayers;\n}\n\n/*\n * Example implementation of a layerable object\n */\nexport class LayerableObjectTrait {\n  activeLayers(defaultActiveLayersFunc) {\n    var result = { withLayers: [], withoutLayers: [] };\n    // go top to bottom in stack... \n    // so the last (dynamically) (de-)activated layers are first...\n    // remember withLayers and withoutLayers in result\n    // this is a bit to \"clever\" to iterate only once...\n    dynamicLayers(result);\n    structuralLayers(result, this);\n    globalLayers(result);\n    // and the global layers are last\n    return result.withLayers;\n  }\n\n  setWithLayers(layers) {\n    this.withLayers = layers;\n  }\n  addWithLayer(layer) {\n    var layers = this.getWithLayers();\n    if (!layers.includes(layer)) {\n      this.setWithLayers(layers.concat([layer]));\n    }\n  }\n  removeWithLayer(layer) {\n    var layers = this.getWithLayers();\n    if (layers.includes(layer)) {\n      this.setWithLayers(layers.filter(l => l !== layer));\n    }\n  }\n  addWithoutLayer(layer) {\n    var layers = this.getWithoutLayers();\n    if (!layers.include(layer)) {\n      this.setWithoutLayers(layers.concat([layer]));\n    }\n  }\n  removeWithoutLayer(layer) {\n    var layers = this.getWithoutLayers();\n    this.setWithoutLayers(layers.filter(l => l !== layer));\n  }\n  setWithoutLayers(layers) {\n    this.withoutLayers = layers;\n  }\n  getWithLayers() {\n    return this.withLayers || [];\n  }\n  getWithoutLayer() {\n    return this.withoutLayers || [];\n  }\n}\n\nexport class LayerableObject extends LayerableObjectTrait {}\n\nexport class COPError {\n  constructor(message) {\n    this._msg = message;\n  }\n  toString() {\n    return \"COP ERROR: \" + this._msg;\n  }\n}\n\nexport class PartialLayerComposition {\n  constructor(obj, functionName, baseFunction, methodType) {\n    this._partialMethods = [baseFunction];\n    this._layers = [undefined];\n    const layers = computeLayersFor(obj);\n    for (var i = 0; i < layers.length; i++) {\n      var layer = layers[i];\n      var partialMethod = lookupLayeredFunctionForObject(obj, layer, functionName, methodType);\n      if (partialMethod) {\n        this._partialMethods.push(partialMethod);\n        this._layers.push(layer);\n      }\n    }\n    this._object = obj;\n  }\n\n  get object() {\n    return this._object;\n  }\n\n  get partialMethods() {\n    return this._partialMethods;\n  }\n\n  get layers() {\n    return this._layers;\n  }\n}\n\nresetLayerStack();\n\n// vim: sw=2"]}