docs: function(methodName, options, controlInstance) {
  			var readyCompute,
                  unableToBind;
  
  			// If we don't have options (a `control` instance), we'll run this later. If we have
  			// options, run `can.sub` to replace the action template `{}` with values from the `options`
  			// or `window`. If a `{}` template resolves to an object, `convertedName` will be an array.
  			// In that case, the event name we want will be the last item in that array.
  			paramReplacer.lastIndex = 0;
  			if (options || !paramReplacer.test(methodName)) {
                  var controlActionData = function() {
  					var delegate;
  
  					// Set the delegate target and get the name of the event we're listening to.
  					var name = methodName.replace(paramReplacer, function(matched, key) {
  						var value, parent;
  
  						// If listening directly to a delegate target, set it
  						if (this._isDelegate(options, key)) {
  							delegate = this._getDelegate(options, key);
  							return "";
  						}
  
  						// If key contains part of the lookup path, remove it.
  						// This is needed for bindings like {viewModel.foo} in can-component's Control.
  						key = this._removeDelegateFromKey(key);
  
  						// set the parent (where the key will be read from)
  						parent = this._lookup(options)[0];
  
  						value = observeReader.read(parent, observeReader.reads(key), {
  							// if we find a compute, we should bind on that and not read it
  							readCompute: false
  						}).value;
  
  						// If `value` is undefined try to get the value from the window.
  						if (value === undefined && typeof window !== 'undefined') {
  							value = get(window, key);
  						}
  
  						// if the parent is not an observable and we don't have a value, show a warning
  						// in this situation, it is not possible for the event handler to be triggered
  						if (!parent || !(canReflect.isObservableLike(parent) && canReflect.isMapLike(parent)) && !value) {
                              unableToBind = true;
  							return null;
  						}
  
  						// If `value` is a string we just return it, otherwise we set it as a delegate target.
  						if (typeof value === "string") {
  							return value;
  						} else {
  							delegate = value;
  							return "";
  						}
  					}.bind(this));
  
  					// removing spaces that get added when converting
  					// `{element} click` -> ` click`
  					name = name.trim();
  
  					// Get the name of the `event` we're listening to.
  					var parts = name.split(/\s+/g),
  						event = parts.pop();
  
  					// Return everything needed to handle the event we're listening to.
  					return {
  						processor: this.processors[event] || basicProcessor,
  						parts: [name, parts.join(" "), event],
  						delegate: delegate || undefined
  					};
  				};
  
          //!steal-remove-start
          if(process.env.NODE_ENV !== 'production') {
  		    	Object.defineProperty(controlActionData, "name", {
  		      	value: canReflect.getName(controlInstance || this.prototype) + "["+methodName+"].actionData",
  		      });
  	      }
          //!steal-remove-end
  
  				readyCompute = new Observation(controlActionData, this);
  
  
  				if (controlInstance) {
  					// Create a handler function that we'll use to handle the `change` event on the `readyCompute`.
  					var handler = function(actionData) {
  						// unbinds the old binding
  						controlInstance._bindings.control[methodName](controlInstance.element);
  						// binds the new
  						controlInstance._bindings.control[methodName] = actionData.processor(
  							actionData.delegate || controlInstance.element,
  							actionData.parts[2], actionData.parts[1], methodName, controlInstance);
  					};
  
            //!steal-remove-start
            if(process.env.NODE_ENV !== 'production') {
            	Object.defineProperty(handler, "name", {
              	value: canReflect.getName(controlInstance) + "["+methodName+"].handler",
              });
            }
  					//!steal-remove-end
  
  
  					canReflect.onValue(readyCompute, handler, "mutate");
            //!steal-remove-start
            if(process.env.NODE_ENV !== 'production') {
  	          if(unableToBind) {
  	          	dev.log('can-control: No property found for handling ' + methodName);
  						}
  					}
  					//!steal-remove-end
  
  					controlInstance._bindings.readyComputes[methodName] = {
  						compute: readyCompute,
  						handler: handler
  					};
  				}
  
  				return readyCompute.get();
  			}
  		}