#### listen Calls setup, but presets bind and unbind to operate on a compute
165270
function(el, compute, change, queueName) {
		return live.setup(
			el,
			function bind() {
				// listen to notify, so on a change, this can
				// teardown all children quickly.
				canReflect.onValue(compute, change, queueName || "notify");
				//compute.computeInstance.addEventListener('change', change);

				//!steal-remove-start
				if(process.env.NODE_ENV !== 'production') {
					canReflectDeps.addMutatedBy(el, compute);
				}
				//!steal-remove-end
			},
			function unbind(data) {
				canReflect.offValue(compute, change, queueName || "notify");

				//!steal-remove-start
				if(process.env.NODE_ENV !== 'production') {
					canReflectDeps.deleteMutatedBy(el, compute);
				}
				//!steal-remove-end

				//compute.computeInstance.removeEventListener('change', change);
				if (data.nodeList) {
					nodeLists.unregister(data.nodeList);
				}
			}
		);
	}
1174347
function (keyOrList, func) { // alias: `unbind`
				var i = listeners.length, listener;
				if (arguments.length === 1) {
					func = keyOrList;
					keyOrList = 0;
				}
				while (--i >= 0) {
					listener = listeners[i];
					if (listener.cb === func &&
						(!keyOrList || keysMatch(listener.keys, keyOrList)))
					{
						listeners.splice(i, 1);
					}
				}
				return me;
			}
1002558
function initRadio(elem, parsed){
  var self = this;
  var wc = this.$watch(parsed, function( newValue ){
    if(newValue == elem.value) elem.checked = true;
    else elem.checked = false;
  }, STABLE);


  var handler = function handler(){
    var value = this.value;
    parsed.set(self, value);
    self.$update();
  }
  if(parsed.set) dom.on(elem, "change", handler)
  // beacuse only after compile(init), the dom structrue is exsit. 
  if(parsed.get(self) === undefined){
    if(elem.checked) {
      parsed.set(self, elem.value);
    }
  }

  return function destroy(){
    if(parsed.set) dom.off(elem, "change", handler)
  }
}
988390
function bind(fn) {
  if (typeof fn !== 'function') return;
  if (support) return events.bind(window, 'hashchange', fn);
  if (running) return;
  running = true;
  fix(fn);
  return fn;
}
736300
function(initialValue, settings){
		var self = this;
		// This is the async getter function.  Depending on how many arguments the function takes,
		// we setup bindings differently.
		var getter = settings.fn;
		var bindings;

		this.value = initialValue;

		// This compute will call update with the new value itself.
		this._setUpdates = true;

		// An "async" compute has a `lastSetValue` that represents
		// the last value `compute.set` was called with.
		// The following creates `lastSetValue` as a can.Compute so when
		//  `lastSetValue` is changed, the `getter` can see that change
		// and automatically update itself.
		this.lastSetValue = new Compute(initialValue);

		// Wires up setting this compute to set `lastSetValue`.
		// If the new value matches the last setValue, do nothing.
		this._set = function(newVal){
			if(newVal === self.lastSetValue.get()) {
				return this.value;
			}

			return self.lastSetValue.set(newVal);
		};

		// Wire up the get to pass the lastNewValue
		this._get = function() {
			return getter.call(settings.context, self.lastSetValue.get() );
		};

		if(getter.length === 0) {
			// If it takes no arguments, it should behave just like a Getter compute.
			bindings = setupComputeHandlers(this, getter, settings.context);
		} else if(getter.length === 1) {
			// If it has a single argument, pass it the last setValue.
			bindings = setupComputeHandlers(this, function() {
				return getter.call(settings.context, self.lastSetValue.get() );
			}, settings);

		} else {
			// If the function takes 2 arguments, the second argument is a function
			// that should update the value of the compute (`setValue`). To make this we need
			// the "normal" updater function because we are about to overwrite it.
			var oldUpdater = this.updater,
				resolve = ObservationRecorder.ignore(function(newVal) {
					oldUpdater.call(self, newVal, self.value);
				});

			// Because `setupComputeHandlers` calls `updater` internally with its
			// observation._value as `oldValue` and that might not be up to date,
			// we overwrite updater to always use self.value.
			this.updater = function(newVal) {
				oldUpdater.call(self, newVal, self.value);
			};


			bindings = setupComputeHandlers(this, function() {
				// Call getter, and get new value
				var res = getter.call(settings.context, self.lastSetValue.get(), resolve);
				// If undefined is returned, don't update the value.
				return res !== undefined ? res : this.value;
			}, this);
		}

		assign(this, bindings);
	}
416771
function resolvePreset(preset) {
  let fn, options;

  if (Array.isArray(preset)) {
    fn = preset[0];
    options = preset[1];
  } else {
    fn = preset;
    options = {};
  }

  // For JS setups where we invoked the preset already
  if (preset.plugins) {
    return Promise.resolve(preset.plugins);
  }

  // Provide an alias for the default preset, as it is built-in.
  if (fn === 'default') {
    return Promise.resolve(require('cssnano-preset-default')(options).plugins);
  }

  // For non-JS setups; we'll need to invoke the preset ourselves.
  if (typeof fn === 'function') {
    return Promise.resolve(fn(options).plugins);
  }

  // Try loading a preset from node_modules
  if (isResolvable(fn)) {
    return Promise.resolve(require(fn)(options).plugins);
  }

  const sugar = `cssnano-preset-${fn}`;

  // Try loading a preset from node_modules (sugar)
  if (isResolvable(sugar)) {
    return Promise.resolve(require(sugar)(options).plugins);
  }

  // If all else fails, we probably have a typo in the config somewhere
  throw new Error(
    `Cannot load preset "${fn}". Please check your configuration for errors and try again.`
  );
}
79852
function bindAsObject (vm, key, source, cancelCallback) {
  defineReactive(vm, key, {})
  var cb = source.on('value', function (snapshot) {
    vm[key] = createRecord(snapshot)
  }, cancelCallback)
  vm._wilddogListeners[key] = { value: cb }
}
60548
def bind_mounts
      ret_val = @launcher.bind_mounts
      ret_val << File.dirname(@config['listen'])
      ret_val += valid_web_paths
      ret_val.uniq
    end
65729
function bindToFunction(target, entity, evt, method){
      target.listenTo(entity, evt, method, target);
  }
1151297
function Precompiler(groupSettings, callback) {
      var self;
      this.settings = groupSettings;
      this.callback = callback;
      if (this.settings.source) {
        this.settings.source = path.normalize(globalSettings.dir + '/' + this.settings.source);
      } else {
        throw 'ERR: No source directory defined for ' + groupSettings.namespace;
      }
      if (this.settings.output) {
        this.settings.output = path.normalize(globalSettings.dir + '/' + this.settings.output);
      } else {
        if (this.callback == null) {
          throw 'ERR: No callback or output directory defined for ' + groupSettings.namespace;
        }
      }
      self = this;
      Namespacer(this.settings, function(err, res) {
        if (err != null) {
          throw err;
        } else {
          return self.namespaces = res.join('\n') + '\n';
        }
      });
    }
1268097
function() {
  setups = {}
  model.servers = []
  model.headers = []
  model.ui = _.clone(uidefaults)
  model.controls = _.clone(controldefaults)

  if (DEBUG) { console.log('discover started') }
  wampsession.publish('discover', [])
  setTimeout(function () {
    if (DEBUG) { console.log('discover ended') }
    model.servers = _.values(setups)
  }, 500)
}
541676
function set(appName, limits, callback) {
    if (!isObject(limits)) {
      return callback(new Error('To set a variable pass an object'));
    }

    var keyValues = {};

    if (limits.hasOwnProperty('memory')) {
      keyValues.memory = limits.memory;
    }

    if (limits.hasOwnProperty('cpu')) {
      keyValues.cpu = limits.cpu;
    }

    if (Object.keys(keyValues).length === 0) {
      return callback(new Error('Only cpu and memory limits are valid'));
    }

    commons.post(format('/%s/apps/%s/config/', deis.version, appName), keyValues,
        function onSetResponse(err, result) {
          callback(err, result ? extractLimits(result) : null);
        });
  }
461193
function _$set(kp, value, lazyEmit) {
        if (_destroy) return _destroyNotice()

        return _$sync(kp, value, lazyEmit)
        // if (!diff) return
        /**
         *  Base type change of object type will be trigger change event
         *  next and pre value are not keypath value but property value
         */
        // if ( kp == diff.mounted && $util.diff(diff.next, diff.pre) ) {
        //     var propname = diff.mounted
        //     // emit change immediately
        //     _emitChange(propname, diff.next, diff.pre)
        // }
    }
157535
function Prox(settings) {

    var self = this;
    this.log = settings.log;

    this.devices = new DeviceManager(settings);
    this.server = new ServerConnection(settings);

    this.server.on('listening', function (localPort, localAddress, protocol) {
        self.log('Web-Remote-Control Proxy Server listening to "' + protocol + '" requests on ' + localAddress + ':' + localPort);
    });

    this.server.on('error', this.handleError.bind(this));

    this.server.on('socket-close', function (socketId) {
        self.devices.removeBySocketId(socketId);
    });

    this.server.on('register', this.registerDevice.bind(this));
    this.server.on('ping', this.respondToPing.bind(this));
    this.server.on('status', this.forwardStatus.bind(this));
    this.server.on('command', this.forwardCommand.bind(this));

    this.stickers = new StickyMessages();

    EventEmitter.call(this);

}
1029731
function (bind) {
                if (!this.__isValidProcessingBind(bind)) {
                    return;
                }

                this.registerBinding(bind, this._notifyProcessingChange);

                // save for later use and disposal
                this._processing = {
                    inside : bind.inside,
                    to : bind.to
                };
            }
352321
function setupEvent(element, eType, handler, capture) {
  notifyOfNextSubs[eType] = [];
  subsIDs[eType] = {};
  element.addEventListener(
    eType,
    handler,
    passiveEventSupport
      ? {
          capture,
          // don't set click listener as passive because syntheticClick may call preventDefault
          passive: eType !== 'click',
        }
      : capture,
  );
}
1334273
function Server(options) {
  var that = this;
  that.options = options || {};
  that.stack = [];
  bind.call(that);
}