renalware-core 2.0.157 → 2.0.162

data/app/assets/javascripts/renalware/rollup_compiled.js

@@ -1910,16 +1910,17 @@ if (window.MutationObserver) {
 }
 
 var EventListener = function() {
-  function EventListener(eventTarget, eventName) {
+  function EventListener(eventTarget, eventName, eventOptions) {
     this.eventTarget = eventTarget;
     this.eventName = eventName;
+    this.eventOptions = eventOptions;
     this.unorderedBindings = new Set();
   }
   EventListener.prototype.connect = function() {
-    this.eventTarget.addEventListener(this.eventName, this, false);
+    this.eventTarget.addEventListener(this.eventName, this, this.eventOptions);
   };
   EventListener.prototype.disconnect = function() {
-    this.eventTarget.removeEventListener(this.eventName, this, false);
+    this.eventTarget.removeEventListener(this.eventName, this, this.eventOptions);
   };
   EventListener.prototype.bindingConnected = function(binding) {
     this.unorderedBindings.add(binding);
@@ -1945,7 +1946,7 @@ var EventListener = function() {
         return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;
       });
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   return EventListener;
@@ -1994,7 +1995,7 @@ var Dispatcher = function() {
         return listeners.concat(Array.from(map.values()));
       }, []);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Dispatcher.prototype.bindingConnected = function(binding) {
@@ -2010,20 +2011,21 @@ var Dispatcher = function() {
     this.application.handleError(error, "Error " + message, detail);
   };
   Dispatcher.prototype.fetchEventListenerForBinding = function(binding) {
-    var eventTarget = binding.eventTarget, eventName = binding.eventName;
-    return this.fetchEventListener(eventTarget, eventName);
+    var eventTarget = binding.eventTarget, eventName = binding.eventName, eventOptions = binding.eventOptions;
+    return this.fetchEventListener(eventTarget, eventName, eventOptions);
   };
-  Dispatcher.prototype.fetchEventListener = function(eventTarget, eventName) {
+  Dispatcher.prototype.fetchEventListener = function(eventTarget, eventName, eventOptions) {
     var eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
-    var eventListener = eventListenerMap.get(eventName);
+    var cacheKey = this.cacheKey(eventName, eventOptions);
+    var eventListener = eventListenerMap.get(cacheKey);
     if (!eventListener) {
-      eventListener = this.createEventListener(eventTarget, eventName);
-      eventListenerMap.set(eventName, eventListener);
+      eventListener = this.createEventListener(eventTarget, eventName, eventOptions);
+      eventListenerMap.set(cacheKey, eventListener);
     }
     return eventListener;
   };
-  Dispatcher.prototype.createEventListener = function(eventTarget, eventName) {
-    var eventListener = new EventListener(eventTarget, eventName);
+  Dispatcher.prototype.createEventListener = function(eventTarget, eventName, eventOptions) {
+    var eventListener = new EventListener(eventTarget, eventName, eventOptions);
     if (this.started) {
       eventListener.connect();
     }
@@ -2037,17 +2039,25 @@ var Dispatcher = function() {
     }
     return eventListenerMap;
   };
+  Dispatcher.prototype.cacheKey = function(eventName, eventOptions) {
+    var parts = [ eventName ];
+    Object.keys(eventOptions).sort().forEach(function(key) {
+      parts.push("" + (eventOptions[key] ? "" : "!") + key);
+    });
+    return parts.join(":");
+  };
   return Dispatcher;
 }();
 
-var descriptorPattern = /^((.+?)(@(window|document))?->)?(.+?)(#(.+))?$/;
+var descriptorPattern = /^((.+?)(@(window|document))?->)?(.+?)(#([^:]+?))(:(.+))?$/;
 
-function parseDescriptorString(descriptorString) {
+function parseActionDescriptorString(descriptorString) {
   var source = descriptorString.trim();
   var matches = source.match(descriptorPattern) || [];
   return {
     eventTarget: parseEventTarget(matches[4]),
     eventName: matches[2],
+    eventOptions: matches[9] ? parseEventOptions(matches[9]) : {},
     identifier: matches[5],
     methodName: matches[7]
   };
@@ -2061,6 +2071,14 @@ function parseEventTarget(eventTargetName) {
   }
 }
 
+function parseEventOptions(eventOptions) {
+  return eventOptions.split(":").reduce(function(options, token) {
+    var _a;
+    return Object.assign(options, (_a = {}, _a[token.replace(/^!/, "")] = !/^!/.test(token), 
+    _a));
+  }, {});
+}
+
 function stringifyEventTarget(eventTarget) {
   if (eventTarget == window) {
     return "window";
@@ -2075,11 +2093,12 @@ var Action = function() {
     this.index = index;
     this.eventTarget = descriptor.eventTarget || element;
     this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error("missing event name");
+    this.eventOptions = descriptor.eventOptions || {};
     this.identifier = descriptor.identifier || error("missing identifier");
     this.methodName = descriptor.methodName || error("missing method name");
   }
   Action.forToken = function(token) {
-    return new this(token.element, token.index, parseDescriptorString(token.content));
+    return new this(token.element, token.index, parseActionDescriptorString(token.content));
   };
   Action.prototype.toString = function() {
     var eventNameSuffix = this.eventTargetName ? "@" + this.eventTargetName : "";
@@ -2089,7 +2108,7 @@ var Action = function() {
     get: function() {
       return stringifyEventTarget(this.eventTarget);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   return Action;
@@ -2106,13 +2125,13 @@ var defaultEventNames = {
     return "submit";
   },
   input: function(e) {
-    return e.getAttribute("type") == "submit" ? "click" : "change";
+    return e.getAttribute("type") == "submit" ? "click" : "input";
   },
   select: function(e) {
     return "change";
   },
   textarea: function(e) {
-    return "change";
+    return "input";
   }
 };
 
@@ -2136,21 +2155,28 @@ var Binding = function() {
     get: function() {
       return this.action.index;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Binding.prototype, "eventTarget", {
     get: function() {
       return this.action.eventTarget;
     },
-    enumerable: true,
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Binding.prototype, "eventOptions", {
+    get: function() {
+      return this.action.eventOptions;
+    },
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Binding.prototype, "identifier", {
     get: function() {
       return this.context.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Binding.prototype.handleEvent = function(event) {
@@ -2162,7 +2188,7 @@ var Binding = function() {
     get: function() {
       return this.action.eventName;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Binding.prototype, "method", {
@@ -2173,7 +2199,7 @@ var Binding = function() {
       }
       throw new Error('Action "' + this.action + '" references undefined method "' + this.methodName + '"');
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Binding.prototype.invokeWithEvent = function(event) {
@@ -2198,35 +2224,35 @@ var Binding = function() {
     } else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {
       return this.scope.containsElement(eventTarget);
     } else {
-      return true;
+      return this.scope.containsElement(this.action.element);
     }
   };
   Object.defineProperty(Binding.prototype, "controller", {
     get: function() {
       return this.context.controller;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Binding.prototype, "methodName", {
     get: function() {
       return this.action.methodName;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Binding.prototype, "element", {
     get: function() {
       return this.scope.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Binding.prototype, "scope", {
     get: function() {
       return this.context.scope;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   return Binding;
@@ -2380,14 +2406,14 @@ var AttributeObserver = function() {
     get: function() {
       return this.elementObserver.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(AttributeObserver.prototype, "selector", {
     get: function() {
       return "[" + this.attributeName + "]";
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   AttributeObserver.prototype.start = function() {
@@ -2403,7 +2429,7 @@ var AttributeObserver = function() {
     get: function() {
       return this.elementObserver.started;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   AttributeObserver.prototype.matchElement = function(element) {
@@ -2432,6 +2458,114 @@ var AttributeObserver = function() {
   return AttributeObserver;
 }();
 
+var StringMapObserver = function() {
+  function StringMapObserver(element, delegate) {
+    var _this = this;
+    this.element = element;
+    this.delegate = delegate;
+    this.started = false;
+    this.stringMap = new Map();
+    this.mutationObserver = new MutationObserver(function(mutations) {
+      return _this.processMutations(mutations);
+    });
+  }
+  StringMapObserver.prototype.start = function() {
+    if (!this.started) {
+      this.started = true;
+      this.mutationObserver.observe(this.element, {
+        attributes: true
+      });
+      this.refresh();
+    }
+  };
+  StringMapObserver.prototype.stop = function() {
+    if (this.started) {
+      this.mutationObserver.takeRecords();
+      this.mutationObserver.disconnect();
+      this.started = false;
+    }
+  };
+  StringMapObserver.prototype.refresh = function() {
+    if (this.started) {
+      for (var _i = 0, _a = this.knownAttributeNames; _i < _a.length; _i++) {
+        var attributeName = _a[_i];
+        this.refreshAttribute(attributeName);
+      }
+    }
+  };
+  StringMapObserver.prototype.processMutations = function(mutations) {
+    if (this.started) {
+      for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {
+        var mutation = mutations_1[_i];
+        this.processMutation(mutation);
+      }
+    }
+  };
+  StringMapObserver.prototype.processMutation = function(mutation) {
+    var attributeName = mutation.attributeName;
+    if (attributeName) {
+      this.refreshAttribute(attributeName);
+    }
+  };
+  StringMapObserver.prototype.refreshAttribute = function(attributeName) {
+    var key = this.delegate.getStringMapKeyForAttribute(attributeName);
+    if (key != null) {
+      if (!this.stringMap.has(attributeName)) {
+        this.stringMapKeyAdded(key, attributeName);
+      }
+      var value = this.element.getAttribute(attributeName);
+      if (this.stringMap.get(attributeName) != value) {
+        this.stringMapValueChanged(value, key);
+      }
+      if (value == null) {
+        this.stringMap.delete(attributeName);
+        this.stringMapKeyRemoved(key, attributeName);
+      } else {
+        this.stringMap.set(attributeName, value);
+      }
+    }
+  };
+  StringMapObserver.prototype.stringMapKeyAdded = function(key, attributeName) {
+    if (this.delegate.stringMapKeyAdded) {
+      this.delegate.stringMapKeyAdded(key, attributeName);
+    }
+  };
+  StringMapObserver.prototype.stringMapValueChanged = function(value, key) {
+    if (this.delegate.stringMapValueChanged) {
+      this.delegate.stringMapValueChanged(value, key);
+    }
+  };
+  StringMapObserver.prototype.stringMapKeyRemoved = function(key, attributeName) {
+    if (this.delegate.stringMapKeyRemoved) {
+      this.delegate.stringMapKeyRemoved(key, attributeName);
+    }
+  };
+  Object.defineProperty(StringMapObserver.prototype, "knownAttributeNames", {
+    get: function() {
+      return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)));
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(StringMapObserver.prototype, "currentAttributeNames", {
+    get: function() {
+      return Array.from(this.element.attributes).map(function(attribute) {
+        return attribute.name;
+      });
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(StringMapObserver.prototype, "recordedAttributeNames", {
+    get: function() {
+      return Array.from(this.stringMap.keys());
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return StringMapObserver;
+}();
+
 function add(map, key, value) {
   fetch(map, key).add(value);
 }
@@ -2468,7 +2602,7 @@ var Multimap = function() {
         return values.concat(Array.from(set));
       }, []);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Multimap.prototype, "size", {
@@ -2478,7 +2612,7 @@ var Multimap = function() {
         return size + set.size;
       }, 0);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Multimap.prototype.add = function(key, value) {
@@ -2517,12 +2651,15 @@ var Multimap = function() {
 }();
 
 var __extends = window && window.__extends || function() {
-  var extendStatics = Object.setPrototypeOf || {
-    __proto__: []
-  } instanceof Array && function(d, b) {
-    d.__proto__ = b;
-  } || function(d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function(d, b) {
+      d.__proto__ = b;
+    } || function(d, b) {
+      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    };
+    return extendStatics(d, b);
   };
   return function(d, b) {
     extendStatics(d, b);
@@ -2544,7 +2681,7 @@ var IndexedMultimap = function(_super) {
     get: function() {
       return Array.from(this.keysByValue.keys());
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   IndexedMultimap.prototype.add = function(key, value) {
@@ -2575,7 +2712,7 @@ var TokenListObserver = function() {
     get: function() {
       return this.attributeObserver.started;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   TokenListObserver.prototype.start = function() {
@@ -2591,14 +2728,14 @@ var TokenListObserver = function() {
     get: function() {
       return this.attributeObserver.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(TokenListObserver.prototype, "attributeName", {
     get: function() {
       return this.attributeObserver.attributeName;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   TokenListObserver.prototype.elementMatchedAttribute = function(element) {
@@ -2690,7 +2827,7 @@ var ValueListObserver = function() {
     get: function() {
       return this.tokenListObserver.started;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   ValueListObserver.prototype.start = function() {
@@ -2706,14 +2843,14 @@ var ValueListObserver = function() {
     get: function() {
       return this.tokenListObserver.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(ValueListObserver.prototype, "attributeName", {
     get: function() {
       return this.tokenListObserver.attributeName;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   ValueListObserver.prototype.tokenMatched = function(token) {
@@ -2786,35 +2923,35 @@ var BindingObserver = function() {
     get: function() {
       return this.context.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(BindingObserver.prototype, "identifier", {
     get: function() {
       return this.context.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(BindingObserver.prototype, "actionAttribute", {
     get: function() {
       return this.schema.actionAttribute;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(BindingObserver.prototype, "schema", {
     get: function() {
       return this.context.schema;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(BindingObserver.prototype, "bindings", {
     get: function() {
       return Array.from(this.bindingsByAction.values());
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   BindingObserver.prototype.connectAction = function(action) {
@@ -2851,12 +2988,78 @@ var BindingObserver = function() {
   return BindingObserver;
 }();
 
+var ValueObserver = function() {
+  function ValueObserver(context, receiver) {
+    this.context = context;
+    this.receiver = receiver;
+    this.stringMapObserver = new StringMapObserver(this.element, this);
+    this.valueDescriptorMap = this.controller.valueDescriptorMap;
+    this.invokeChangedCallbacksForDefaultValues();
+  }
+  ValueObserver.prototype.start = function() {
+    this.stringMapObserver.start();
+  };
+  ValueObserver.prototype.stop = function() {
+    this.stringMapObserver.stop();
+  };
+  Object.defineProperty(ValueObserver.prototype, "element", {
+    get: function() {
+      return this.context.element;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(ValueObserver.prototype, "controller", {
+    get: function() {
+      return this.context.controller;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  ValueObserver.prototype.getStringMapKeyForAttribute = function(attributeName) {
+    if (attributeName in this.valueDescriptorMap) {
+      return this.valueDescriptorMap[attributeName].name;
+    }
+  };
+  ValueObserver.prototype.stringMapValueChanged = function(attributeValue, name) {
+    this.invokeChangedCallbackForValue(name);
+  };
+  ValueObserver.prototype.invokeChangedCallbacksForDefaultValues = function() {
+    for (var _i = 0, _a = this.valueDescriptors; _i < _a.length; _i++) {
+      var _b = _a[_i], key = _b.key, name_1 = _b.name, defaultValue = _b.defaultValue;
+      if (defaultValue != undefined && !this.controller.data.has(key)) {
+        this.invokeChangedCallbackForValue(name_1);
+      }
+    }
+  };
+  ValueObserver.prototype.invokeChangedCallbackForValue = function(name) {
+    var methodName = name + "Changed";
+    var method = this.receiver[methodName];
+    if (typeof method == "function") {
+      var value = this.receiver[name];
+      method.call(this.receiver, value);
+    }
+  };
+  Object.defineProperty(ValueObserver.prototype, "valueDescriptors", {
+    get: function() {
+      var valueDescriptorMap = this.valueDescriptorMap;
+      return Object.keys(valueDescriptorMap).map(function(key) {
+        return valueDescriptorMap[key];
+      });
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return ValueObserver;
+}();
+
 var Context = function() {
   function Context(module, scope) {
     this.module = module;
     this.scope = scope;
     this.controller = new module.controllerConstructor(this);
     this.bindingObserver = new BindingObserver(this, this.dispatcher);
+    this.valueObserver = new ValueObserver(this, this.controller);
     try {
       this.controller.initialize();
     } catch (error) {
@@ -2865,6 +3068,7 @@ var Context = function() {
   }
   Context.prototype.connect = function() {
     this.bindingObserver.start();
+    this.valueObserver.start();
     try {
       this.controller.connect();
     } catch (error) {
@@ -2877,48 +3081,49 @@ var Context = function() {
     } catch (error) {
       this.handleError(error, "disconnecting controller");
     }
+    this.valueObserver.stop();
     this.bindingObserver.stop();
   };
   Object.defineProperty(Context.prototype, "application", {
     get: function() {
       return this.module.application;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Context.prototype, "identifier", {
     get: function() {
       return this.module.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Context.prototype, "schema", {
     get: function() {
       return this.application.schema;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Context.prototype, "dispatcher", {
     get: function() {
       return this.application.dispatcher;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Context.prototype, "element", {
     get: function() {
       return this.scope.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Context.prototype, "parentElement", {
     get: function() {
       return this.element.parentElement;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Context.prototype.handleError = function(error, message, detail) {
@@ -2936,13 +3141,55 @@ var Context = function() {
   return Context;
 }();
 
+function readInheritableStaticArrayValues(constructor, propertyName) {
+  var ancestors = getAncestorsForConstructor(constructor);
+  return Array.from(ancestors.reduce(function(values, constructor) {
+    getOwnStaticArrayValues(constructor, propertyName).forEach(function(name) {
+      return values.add(name);
+    });
+    return values;
+  }, new Set()));
+}
+
+function readInheritableStaticObjectPairs(constructor, propertyName) {
+  var ancestors = getAncestorsForConstructor(constructor);
+  return ancestors.reduce(function(pairs, constructor) {
+    pairs.push.apply(pairs, getOwnStaticObjectPairs(constructor, propertyName));
+    return pairs;
+  }, []);
+}
+
+function getAncestorsForConstructor(constructor) {
+  var ancestors = [];
+  while (constructor) {
+    ancestors.push(constructor);
+    constructor = Object.getPrototypeOf(constructor);
+  }
+  return ancestors.reverse();
+}
+
+function getOwnStaticArrayValues(constructor, propertyName) {
+  var definition = constructor[propertyName];
+  return Array.isArray(definition) ? definition : [];
+}
+
+function getOwnStaticObjectPairs(constructor, propertyName) {
+  var definition = constructor[propertyName];
+  return definition ? Object.keys(definition).map(function(key) {
+    return [ key, definition[key] ];
+  }) : [];
+}
+
 var __extends$1 = window && window.__extends || function() {
-  var extendStatics = Object.setPrototypeOf || {
-    __proto__: []
-  } instanceof Array && function(d, b) {
-    d.__proto__ = b;
-  } || function(d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function(d, b) {
+      d.__proto__ = b;
+    } || function(d, b) {
+      for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    };
+    return extendStatics(d, b);
   };
   return function(d, b) {
     extendStatics(d, b);
@@ -2953,32 +3200,83 @@ var __extends$1 = window && window.__extends || function() {
   };
 }();
 
-function blessDefinition(definition) {
-  return {
-    identifier: definition.identifier,
-    controllerConstructor: blessControllerConstructor(definition.controllerConstructor)
-  };
+var __spreadArrays = window && window.__spreadArrays || function() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, 
+  k++) r[k] = a[j];
+  return r;
+};
+
+function bless(constructor) {
+  return shadow(constructor, getBlessedProperties(constructor));
+}
+
+function shadow(constructor, properties) {
+  var shadowConstructor = extend(constructor);
+  var shadowProperties = getShadowProperties(constructor.prototype, properties);
+  Object.defineProperties(shadowConstructor.prototype, shadowProperties);
+  return shadowConstructor;
+}
+
+function getBlessedProperties(constructor) {
+  var blessings = readInheritableStaticArrayValues(constructor, "blessings");
+  return blessings.reduce(function(blessedProperties, blessing) {
+    var properties = blessing(constructor);
+    for (var key in properties) {
+      var descriptor = blessedProperties[key] || {};
+      blessedProperties[key] = Object.assign(descriptor, properties[key]);
+    }
+    return blessedProperties;
+  }, {});
+}
+
+function getShadowProperties(prototype, properties) {
+  return getOwnKeys(properties).reduce(function(shadowProperties, key) {
+    var _a;
+    var descriptor = getShadowedDescriptor(prototype, properties, key);
+    if (descriptor) {
+      Object.assign(shadowProperties, (_a = {}, _a[key] = descriptor, _a));
+    }
+    return shadowProperties;
+  }, {});
 }
 
-function blessControllerConstructor(controllerConstructor) {
-  var constructor = extend(controllerConstructor);
-  constructor.bless();
-  return constructor;
+function getShadowedDescriptor(prototype, properties, key) {
+  var shadowingDescriptor = Object.getOwnPropertyDescriptor(prototype, key);
+  var shadowedByValue = shadowingDescriptor && "value" in shadowingDescriptor;
+  if (!shadowedByValue) {
+    var descriptor = Object.getOwnPropertyDescriptor(properties, key).value;
+    if (shadowingDescriptor) {
+      descriptor.get = shadowingDescriptor.get || descriptor.get;
+      descriptor.set = shadowingDescriptor.set || descriptor.set;
+    }
+    return descriptor;
+  }
 }
 
+var getOwnKeys = function() {
+  if (typeof Object.getOwnPropertySymbols == "function") {
+    return function(object) {
+      return __spreadArrays(Object.getOwnPropertyNames(object), Object.getOwnPropertySymbols(object));
+    };
+  } else {
+    return Object.getOwnPropertyNames;
+  }
+}();
+
 var extend = function() {
   function extendWithReflect(constructor) {
-    function Controller() {
-      var _newTarget = this && this instanceof Controller ? this.constructor : void 0;
+    function extended() {
+      var _newTarget = this && this instanceof extended ? this.constructor : void 0;
       return Reflect.construct(constructor, arguments, _newTarget);
     }
-    Controller.prototype = Object.create(constructor.prototype, {
+    extended.prototype = Object.create(constructor.prototype, {
       constructor: {
-        value: Controller
+        value: extended
       }
     });
-    Reflect.setPrototypeOf(Controller, constructor);
-    return Controller;
+    Reflect.setPrototypeOf(extended, constructor);
+    return extended;
   }
   function testReflectExtension() {
     var a = function() {
@@ -2994,16 +3292,23 @@ var extend = function() {
   } catch (error) {
     return function(constructor) {
       return function(_super) {
-        __extends$1(Controller, _super);
-        function Controller() {
+        __extends$1(extended, _super);
+        function extended() {
           return _super !== null && _super.apply(this, arguments) || this;
         }
-        return Controller;
+        return extended;
       }(constructor);
     };
   }
 }();
 
+function blessDefinition(definition) {
+  return {
+    identifier: definition.identifier,
+    controllerConstructor: bless(definition.controllerConstructor)
+  };
+}
+
 var Module = function() {
   function Module(application, definition) {
     this.application = application;
@@ -3015,21 +3320,21 @@ var Module = function() {
     get: function() {
       return this.definition.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Module.prototype, "controllerConstructor", {
     get: function() {
       return this.definition.controllerConstructor;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Module.prototype, "contexts", {
     get: function() {
       return Array.from(this.connectedContexts);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Module.prototype.connectContextForScope = function(scope) {
@@ -3055,6 +3360,48 @@ var Module = function() {
   return Module;
 }();
 
+var ClassMap = function() {
+  function ClassMap(scope) {
+    this.scope = scope;
+  }
+  ClassMap.prototype.has = function(name) {
+    return this.data.has(this.getDataKey(name));
+  };
+  ClassMap.prototype.get = function(name) {
+    return this.data.get(this.getDataKey(name));
+  };
+  ClassMap.prototype.getAttributeName = function(name) {
+    return this.data.getAttributeNameForKey(this.getDataKey(name));
+  };
+  ClassMap.prototype.getDataKey = function(name) {
+    return name + "-class";
+  };
+  Object.defineProperty(ClassMap.prototype, "data", {
+    get: function() {
+      return this.scope.data;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return ClassMap;
+}();
+
+function camelize(value) {
+  return value.replace(/(?:[_-])([a-z0-9])/g, function(_, char) {
+    return char.toUpperCase();
+  });
+}
+
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function dasherize(value) {
+  return value.replace(/([A-Z])/g, function(_, char) {
+    return "-" + char.toLowerCase();
+  });
+}
+
 var DataMap = function() {
   function DataMap(scope) {
     this.scope = scope;
@@ -3063,54 +3410,74 @@ var DataMap = function() {
     get: function() {
       return this.scope.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(DataMap.prototype, "identifier", {
     get: function() {
       return this.scope.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   DataMap.prototype.get = function(key) {
-    key = this.getFormattedKey(key);
-    return this.element.getAttribute(key);
+    var name = this.getAttributeNameForKey(key);
+    return this.element.getAttribute(name);
   };
   DataMap.prototype.set = function(key, value) {
-    key = this.getFormattedKey(key);
-    this.element.setAttribute(key, value);
+    var name = this.getAttributeNameForKey(key);
+    this.element.setAttribute(name, value);
     return this.get(key);
   };
   DataMap.prototype.has = function(key) {
-    key = this.getFormattedKey(key);
-    return this.element.hasAttribute(key);
+    var name = this.getAttributeNameForKey(key);
+    return this.element.hasAttribute(name);
   };
   DataMap.prototype.delete = function(key) {
     if (this.has(key)) {
-      key = this.getFormattedKey(key);
-      this.element.removeAttribute(key);
+      var name_1 = this.getAttributeNameForKey(key);
+      this.element.removeAttribute(name_1);
       return true;
     } else {
       return false;
     }
   };
-  DataMap.prototype.getFormattedKey = function(key) {
+  DataMap.prototype.getAttributeNameForKey = function(key) {
     return "data-" + this.identifier + "-" + dasherize(key);
   };
   return DataMap;
 }();
 
-function dasherize(value) {
-  return value.replace(/([A-Z])/g, function(_, char) {
-    return "-" + char.toLowerCase();
-  });
-}
+var Guide = function() {
+  function Guide(logger) {
+    this.warnedKeysByObject = new WeakMap();
+    this.logger = logger;
+  }
+  Guide.prototype.warn = function(object, key, message) {
+    var warnedKeys = this.warnedKeysByObject.get(object);
+    if (!warnedKeys) {
+      warnedKeys = new Set();
+      this.warnedKeysByObject.set(object, warnedKeys);
+    }
+    if (!warnedKeys.has(key)) {
+      warnedKeys.add(key);
+      this.logger.warn(message, object);
+    }
+  };
+  return Guide;
+}();
 
 function attributeValueContainsToken(attributeName, token) {
   return "[" + attributeName + '~="' + token + '"]';
 }
 
+var __spreadArrays$1 = window && window.__spreadArrays || function() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, 
+  k++) r[k] = a[j];
+  return r;
+};
+
 var TargetSet = function() {
   function TargetSet(scope) {
     this.scope = scope;
@@ -3119,85 +3486,126 @@ var TargetSet = function() {
     get: function() {
       return this.scope.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(TargetSet.prototype, "identifier", {
     get: function() {
       return this.scope.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(TargetSet.prototype, "schema", {
     get: function() {
       return this.scope.schema;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   TargetSet.prototype.has = function(targetName) {
     return this.find(targetName) != null;
   };
   TargetSet.prototype.find = function() {
+    var _this = this;
     var targetNames = [];
     for (var _i = 0; _i < arguments.length; _i++) {
       targetNames[_i] = arguments[_i];
     }
-    var selector = this.getSelectorForTargetNames(targetNames);
-    return this.scope.findElement(selector);
+    return targetNames.reduce(function(target, targetName) {
+      return target || _this.findTarget(targetName) || _this.findLegacyTarget(targetName);
+    }, undefined);
   };
   TargetSet.prototype.findAll = function() {
+    var _this = this;
     var targetNames = [];
     for (var _i = 0; _i < arguments.length; _i++) {
       targetNames[_i] = arguments[_i];
     }
-    var selector = this.getSelectorForTargetNames(targetNames);
+    return targetNames.reduce(function(targets, targetName) {
+      return __spreadArrays$1(targets, _this.findAllTargets(targetName), _this.findAllLegacyTargets(targetName));
+    }, []);
+  };
+  TargetSet.prototype.findTarget = function(targetName) {
+    var selector = this.getSelectorForTargetName(targetName);
+    return this.scope.findElement(selector);
+  };
+  TargetSet.prototype.findAllTargets = function(targetName) {
+    var selector = this.getSelectorForTargetName(targetName);
     return this.scope.findAllElements(selector);
   };
-  TargetSet.prototype.getSelectorForTargetNames = function(targetNames) {
+  TargetSet.prototype.getSelectorForTargetName = function(targetName) {
+    var attributeName = "data-" + this.identifier + "-target";
+    return attributeValueContainsToken(attributeName, targetName);
+  };
+  TargetSet.prototype.findLegacyTarget = function(targetName) {
+    var selector = this.getLegacySelectorForTargetName(targetName);
+    return this.deprecate(this.scope.findElement(selector), targetName);
+  };
+  TargetSet.prototype.findAllLegacyTargets = function(targetName) {
     var _this = this;
-    return targetNames.map(function(targetName) {
-      return _this.getSelectorForTargetName(targetName);
-    }).join(", ");
+    var selector = this.getLegacySelectorForTargetName(targetName);
+    return this.scope.findAllElements(selector).map(function(element) {
+      return _this.deprecate(element, targetName);
+    });
   };
-  TargetSet.prototype.getSelectorForTargetName = function(targetName) {
+  TargetSet.prototype.getLegacySelectorForTargetName = function(targetName) {
     var targetDescriptor = this.identifier + "." + targetName;
     return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);
   };
+  TargetSet.prototype.deprecate = function(element, targetName) {
+    if (element) {
+      var identifier = this.identifier;
+      var attributeName = this.schema.targetAttribute;
+      this.guide.warn(element, "target:" + targetName, "Please replace " + attributeName + '="' + identifier + "." + targetName + '" with data-' + identifier + '-target="' + targetName + '". ' + ("The " + attributeName + " attribute is deprecated and will be removed in a future version of Stimulus."));
+    }
+    return element;
+  };
+  Object.defineProperty(TargetSet.prototype, "guide", {
+    get: function() {
+      return this.scope.guide;
+    },
+    enumerable: false,
+    configurable: true
+  });
   return TargetSet;
 }();
 
+var __spreadArrays$2 = window && window.__spreadArrays || function() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, 
+  k++) r[k] = a[j];
+  return r;
+};
+
 var Scope = function() {
-  function Scope(schema, identifier, element) {
-    this.schema = schema;
-    this.identifier = identifier;
-    this.element = element;
+  function Scope(schema, element, identifier, logger) {
+    var _this = this;
     this.targets = new TargetSet(this);
+    this.classes = new ClassMap(this);
     this.data = new DataMap(this);
+    this.containsElement = function(element) {
+      return element.closest(_this.controllerSelector) === _this.element;
+    };
+    this.schema = schema;
+    this.element = element;
+    this.identifier = identifier;
+    this.guide = new Guide(logger);
   }
   Scope.prototype.findElement = function(selector) {
-    return this.findAllElements(selector)[0];
+    return this.element.matches(selector) ? this.element : this.queryElements(selector).find(this.containsElement);
   };
   Scope.prototype.findAllElements = function(selector) {
-    var head = this.element.matches(selector) ? [ this.element ] : [];
-    var tail = this.filterElements(Array.from(this.element.querySelectorAll(selector)));
-    return head.concat(tail);
-  };
-  Scope.prototype.filterElements = function(elements) {
-    var _this = this;
-    return elements.filter(function(element) {
-      return _this.containsElement(element);
-    });
+    return __spreadArrays$2(this.element.matches(selector) ? [ this.element ] : [], this.queryElements(selector).filter(this.containsElement));
   };
-  Scope.prototype.containsElement = function(element) {
-    return element.closest(this.controllerSelector) === this.element;
+  Scope.prototype.queryElements = function(selector) {
+    return Array.from(this.element.querySelectorAll(selector));
   };
   Object.defineProperty(Scope.prototype, "controllerSelector", {
     get: function() {
       return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   return Scope;
@@ -3222,7 +3630,7 @@ var ScopeObserver = function() {
     get: function() {
       return this.schema.controllerAttribute;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   ScopeObserver.prototype.parseValueForToken = function(token) {
@@ -3230,7 +3638,7 @@ var ScopeObserver = function() {
     var scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);
     var scope = scopesByIdentifier.get(identifier);
     if (!scope) {
-      scope = new Scope(this.schema, identifier, element);
+      scope = this.delegate.createScopeForElementAndIdentifier(element, identifier);
       scopesByIdentifier.set(identifier, scope);
     }
     return scope;
@@ -3273,28 +3681,35 @@ var Router = function() {
     get: function() {
       return this.application.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Router.prototype, "schema", {
     get: function() {
       return this.application.schema;
     },
-    enumerable: true,
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Router.prototype, "logger", {
+    get: function() {
+      return this.application.logger;
+    },
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Router.prototype, "controllerAttribute", {
     get: function() {
       return this.schema.controllerAttribute;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Router.prototype, "modules", {
     get: function() {
       return Array.from(this.modulesByIdentifier.values());
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Router.prototype, "contexts", {
@@ -3303,7 +3718,7 @@ var Router = function() {
         return contexts.concat(module.contexts);
       }, []);
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Router.prototype.start = function() {
@@ -3334,6 +3749,9 @@ var Router = function() {
   Router.prototype.handleError = function(error, message, detail) {
     this.application.handleError(error, message, detail);
   };
+  Router.prototype.createScopeForElementAndIdentifier = function(element, identifier) {
+    return new Scope(this.schema, element, identifier, this.logger);
+  };
   Router.prototype.scopeConnected = function(scope) {
     this.scopesByIdentifier.add(scope.identifier, scope);
     var module = this.modulesByIdentifier.get(scope.identifier);
@@ -3372,6 +3790,11 @@ var defaultSchema = {
 };
 
 var __awaiter = window && window.__awaiter || function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
   return new (P || (P = Promise))(function(resolve, reject) {
     function fulfilled(value) {
       try {
@@ -3388,9 +3811,7 @@ var __awaiter = window && window.__awaiter || function(thisArg, _arguments, P, g
       }
     }
     function step(result) {
-      result.done ? resolve(result.value) : new P(function(resolve) {
-        resolve(result.value);
-      }).then(fulfilled, rejected);
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -3421,8 +3842,9 @@ var __generator = window && window.__generator || function(thisArg, body) {
   function step(op) {
     if (f) throw new TypeError("Generator is already executing.");
     while (_) try {
-      if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
-      if (y = 0, t) op = [ 0, t.value ];
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 
+      0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [ op[0] & 2, t.value ];
       switch (op[0]) {
        case 0:
        case 1:
@@ -3485,6 +3907,13 @@ var __generator = window && window.__generator || function(thisArg, body) {
   }
 };
 
+var __spreadArrays$3 = window && window.__spreadArrays || function() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, 
+  k++) r[k] = a[j];
+  return r;
+};
+
 var Application = function() {
   function Application(element, schema) {
     if (element === void 0) {
@@ -3493,6 +3922,7 @@ var Application = function() {
     if (schema === void 0) {
       schema = defaultSchema;
     }
+    this.logger = console;
     this.element = element;
     this.schema = schema;
     this.dispatcher = new Dispatcher(this);
@@ -3512,16 +3942,16 @@ var Application = function() {
 
          case 1:
           _a.sent();
-          this.router.start();
           this.dispatcher.start();
+          this.router.start();
           return [ 2 ];
         }
       });
     });
   };
   Application.prototype.stop = function() {
-    this.router.stop();
     this.dispatcher.stop();
+    this.router.stop();
   };
   Application.prototype.register = function(identifier, controllerConstructor) {
     this.load({
@@ -3535,7 +3965,7 @@ var Application = function() {
     for (var _i = 1; _i < arguments.length; _i++) {
       rest[_i - 1] = arguments[_i];
     }
-    var definitions = Array.isArray(head) ? head : [ head ].concat(rest);
+    var definitions = Array.isArray(head) ? head : __spreadArrays$3([ head ], rest);
     definitions.forEach(function(definition) {
       return _this.router.loadDefinition(definition);
     });
@@ -3546,7 +3976,7 @@ var Application = function() {
     for (var _i = 1; _i < arguments.length; _i++) {
       rest[_i - 1] = arguments[_i];
     }
-    var identifiers = Array.isArray(head) ? head : [ head ].concat(rest);
+    var identifiers = Array.isArray(head) ? head : __spreadArrays$3([ head ], rest);
     identifiers.forEach(function(identifier) {
       return _this.router.unloadIdentifier(identifier);
     });
@@ -3557,7 +3987,7 @@ var Application = function() {
         return context.controller;
       });
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Application.prototype.getControllerForElementAndIdentifier = function(element, identifier) {
@@ -3565,7 +3995,7 @@ var Application = function() {
     return context ? context.controller : null;
   };
   Application.prototype.handleError = function(error, message, detail) {
-    console.error("%s\n\n%o\n\n%o", message, error, detail);
+    this.logger.error("%s\n\n%o\n\n%o", message, error, detail);
   };
   return Application;
 }();
@@ -3580,122 +4010,259 @@ function domReady() {
   });
 }
 
-function defineTargetProperties(constructor) {
-  var prototype = constructor.prototype;
-  var targetNames = getTargetNamesForConstructor(constructor);
-  targetNames.forEach(function(name) {
-    var _a;
-    return defineLinkedProperties(prototype, (_a = {}, _a[name + "Target"] = {
-      get: function() {
-        var target = this.targets.find(name);
-        if (target) {
-          return target;
-        } else {
-          throw new Error('Missing target element "' + this.identifier + "." + name + '"');
-        }
+function ClassPropertiesBlessing(constructor) {
+  var classes = readInheritableStaticArrayValues(constructor, "classes");
+  return classes.reduce(function(properties, classDefinition) {
+    return Object.assign(properties, propertiesForClassDefinition(classDefinition));
+  }, {});
+}
+
+function propertiesForClassDefinition(key) {
+  var _a;
+  var name = key + "Class";
+  return _a = {}, _a[name] = {
+    get: function() {
+      var classes = this.classes;
+      if (classes.has(key)) {
+        return classes.get(key);
+      } else {
+        var attribute = classes.getAttributeName(key);
+        throw new Error('Missing attribute "' + attribute + '"');
       }
-    }, _a[name + "Targets"] = {
-      get: function() {
-        return this.targets.findAll(name);
+    }
+  }, _a["has" + capitalize(name)] = {
+    get: function() {
+      return this.classes.has(key);
+    }
+  }, _a;
+}
+
+function TargetPropertiesBlessing(constructor) {
+  var targets = readInheritableStaticArrayValues(constructor, "targets");
+  return targets.reduce(function(properties, targetDefinition) {
+    return Object.assign(properties, propertiesForTargetDefinition(targetDefinition));
+  }, {});
+}
+
+function propertiesForTargetDefinition(name) {
+  var _a;
+  return _a = {}, _a[name + "Target"] = {
+    get: function() {
+      var target = this.targets.find(name);
+      if (target) {
+        return target;
+      } else {
+        throw new Error('Missing target element "' + this.identifier + "." + name + '"');
       }
-    }, _a["has" + capitalize(name) + "Target"] = {
+    }
+  }, _a[name + "Targets"] = {
+    get: function() {
+      return this.targets.findAll(name);
+    }
+  }, _a["has" + capitalize(name) + "Target"] = {
+    get: function() {
+      return this.targets.has(name);
+    }
+  }, _a;
+}
+
+function ValuePropertiesBlessing(constructor) {
+  var valueDefinitionPairs = readInheritableStaticObjectPairs(constructor, "values");
+  var propertyDescriptorMap = {
+    valueDescriptorMap: {
       get: function() {
-        return this.targets.has(name);
+        var _this = this;
+        return valueDefinitionPairs.reduce(function(result, valueDefinitionPair) {
+          var _a;
+          var valueDescriptor = parseValueDefinitionPair(valueDefinitionPair);
+          var attributeName = _this.data.getAttributeNameForKey(valueDescriptor.key);
+          return Object.assign(result, (_a = {}, _a[attributeName] = valueDescriptor, _a));
+        }, {});
       }
-    }, _a));
-  });
+    }
+  };
+  return valueDefinitionPairs.reduce(function(properties, valueDefinitionPair) {
+    return Object.assign(properties, propertiesForValueDefinitionPair(valueDefinitionPair));
+  }, propertyDescriptorMap);
 }
 
-function getTargetNamesForConstructor(constructor) {
-  var ancestors = getAncestorsForConstructor(constructor);
-  return Array.from(ancestors.reduce(function(targetNames, constructor) {
-    getOwnTargetNamesForConstructor(constructor).forEach(function(name) {
-      return targetNames.add(name);
-    });
-    return targetNames;
-  }, new Set()));
+function propertiesForValueDefinitionPair(valueDefinitionPair) {
+  var _a;
+  var definition = parseValueDefinitionPair(valueDefinitionPair);
+  var type = definition.type, key = definition.key, name = definition.name;
+  var read = readers[type], write = writers[type] || writers.default;
+  return _a = {}, _a[name] = {
+    get: function() {
+      var value = this.data.get(key);
+      if (value !== null) {
+        return read(value);
+      } else {
+        return definition.defaultValue;
+      }
+    },
+    set: function(value) {
+      if (value === undefined) {
+        this.data.delete(key);
+      } else {
+        this.data.set(key, write(value));
+      }
+    }
+  }, _a["has" + capitalize(name)] = {
+    get: function() {
+      return this.data.has(key);
+    }
+  }, _a;
 }
 
-function getAncestorsForConstructor(constructor) {
-  var ancestors = [];
-  while (constructor) {
-    ancestors.push(constructor);
-    constructor = Object.getPrototypeOf(constructor);
+function parseValueDefinitionPair(_a) {
+  var token = _a[0], typeConstant = _a[1];
+  var type = parseValueTypeConstant(typeConstant);
+  return valueDescriptorForTokenAndType(token, type);
+}
+
+function parseValueTypeConstant(typeConstant) {
+  switch (typeConstant) {
+   case Array:
+    return "array";
+
+   case Boolean:
+    return "boolean";
+
+   case Number:
+    return "number";
+
+   case Object:
+    return "object";
+
+   case String:
+    return "string";
   }
-  return ancestors;
+  throw new Error('Unknown value type constant "' + typeConstant + '"');
 }
 
-function getOwnTargetNamesForConstructor(constructor) {
-  var definition = constructor["targets"];
-  return Array.isArray(definition) ? definition : [];
+function valueDescriptorForTokenAndType(token, type) {
+  var key = dasherize(token) + "-value";
+  return {
+    type: type,
+    key: key,
+    name: camelize(key),
+    get defaultValue() {
+      return defaultValuesByType[type];
+    }
+  };
 }
 
-function defineLinkedProperties(object, properties) {
-  Object.keys(properties).forEach(function(name) {
-    if (!(name in object)) {
-      var descriptor = properties[name];
-      Object.defineProperty(object, name, descriptor);
+var defaultValuesByType = {
+  get array() {
+    return [];
+  },
+  boolean: false,
+  number: 0,
+  get object() {
+    return {};
+  },
+  string: ""
+};
+
+var readers = {
+  array: function(value) {
+    var array = JSON.parse(value);
+    if (!Array.isArray(array)) {
+      throw new TypeError("Expected array");
     }
-  });
+    return array;
+  },
+  boolean: function(value) {
+    return !(value == "0" || value == "false");
+  },
+  number: function(value) {
+    return parseFloat(value);
+  },
+  object: function(value) {
+    var object = JSON.parse(value);
+    if (object === null || typeof object != "object" || Array.isArray(object)) {
+      throw new TypeError("Expected object");
+    }
+    return object;
+  },
+  string: function(value) {
+    return value;
+  }
+};
+
+var writers = {
+  default: writeString,
+  array: writeJSON,
+  object: writeJSON
+};
+
+function writeJSON(value) {
+  return JSON.stringify(value);
 }
 
-function capitalize(name) {
-  return name.charAt(0).toUpperCase() + name.slice(1);
+function writeString(value) {
+  return "" + value;
 }
 
 var Controller = function() {
   function Controller(context) {
     this.context = context;
   }
-  Controller.bless = function() {
-    defineTargetProperties(this);
-  };
   Object.defineProperty(Controller.prototype, "application", {
     get: function() {
       return this.context.application;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Controller.prototype, "scope", {
     get: function() {
       return this.context.scope;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Controller.prototype, "element", {
     get: function() {
       return this.scope.element;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Controller.prototype, "identifier", {
     get: function() {
       return this.scope.identifier;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Controller.prototype, "targets", {
     get: function() {
       return this.scope.targets;
     },
-    enumerable: true,
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(Controller.prototype, "classes", {
+    get: function() {
+      return this.scope.classes;
+    },
+    enumerable: false,
     configurable: true
   });
   Object.defineProperty(Controller.prototype, "data", {
     get: function() {
       return this.scope.data;
     },
-    enumerable: true,
+    enumerable: false,
     configurable: true
   });
   Controller.prototype.initialize = function() {};
   Controller.prototype.connect = function() {};
   Controller.prototype.disconnect = function() {};
+  Controller.blessings = [ ClassPropertiesBlessing, TargetPropertiesBlessing, ValuePropertiesBlessing ];
   Controller.targets = [];
+  Controller.values = {};
   return Controller;
 }();