/*!
Remove listeners registered in `listen`
481702
function mute (conn) {
  if (!conn.db) throw new Error('missing db');
  conn.db.removeAllListeners("close");
  conn.db.removeAllListeners("error");
  conn.db.removeAllListeners("timeout");
  conn.db.removeAllListeners("open");
  conn.db.removeAllListeners("fullsetup");
  conn._listening = false;
}
496395
function() {

		for (var name in this._events_listeners) {

			if (this._events_listeners[name]) {

				Lava.Core.removeGlobalHandler(this._events_listeners[name]);
				this._events_listeners[name] = null;
				this._event_usage_counters[name] = 0;

			}

		}

	}
1181066
function removeListeners() {
        if(!($this->client instanceof \CharlotteDunois\Livia\Client)) {
            return;
        }
        
        $this->client->removeListener('commandPrefixChange', array($this, 'callbackCommandPrefixChange'));
        $this->client->removeListener('commandStatusChange', array($this, 'callbackCommandStatusChange'));
        $this->client->removeListener('groupStatusChange', array($this, 'callbackGroupStatusChange'));
        $this->client->removeListener('guildCreate', array($this, 'callbackGuildCreate'));
        $this->client->removeListener('commandRegister', array($this, 'callbackCommandRegister'));
        $this->client->removeListener('commandReregister', array($this, 'callbackCommandRegister'));
        $this->client->removeListener('groupRegister', array($this, 'callbackGroupRegister'));
        $this->client->removeListener('groupReregister', array($this, 'callbackGroupRegister'));
    }
434768
function recursiveRemoveListeners(listeners: Object | any[]) {
  if (Array.isArray(listeners)) {
    listeners.forEach((listener, index) =>
      recursiveRemoveListeners(listener)
    );
  } else if (listeners instanceof ListenerTracker) {
    const id = listeners.id;
    const object = listeners.object;
    object._parent
        ? object._parent.removeListener(id)
        : object.removeListener(id);
  } else if (typeof listeners === 'object' && listeners !== null) {
    Object.keys(listeners).forEach(key =>
      recursiveRemoveListeners(listeners[key])
    );
  }
}
410119
function () {
            var map = this._getInitialListenersList();
            for (var i = 0; i < map.length; i++) {
                this._removeListener(map[i].evt, map[i].cb);
            }
            this.eventsAlreadyAttached = false;
        }
896183
public function removeListener(Listener $listener) {
		foreach ($this->listeners as $id => $listening) {
			if ($listener == $listening) {
				unset($this->listeners[$id]);
				break;
			}
		}
	}
123443
public function killSoftDeletableListener()
    {
        foreach ($this->em->getEventManager()->getListeners() as $event => $listeners) {
            foreach ($listeners as $hash => $listener) {
                if ($listener instanceof SoftDeleteableListener) {
                    $listenerInst = $listener;
                    break 2;
                }
            }
        }

        $this->em->getEventManager()->removeEventListener(array('onFlush'), $listenerInst);
    }
918477
def remove_listener(registry, listener):
    
    if listener is not None and listener in registry:
        registry.remove(listener)
        return True

    return False
161709
function(type, handler) {
      if (!this.listeners_)
        return;
      if (type in this.listeners_) {
        var handlers = this.listeners_[type];
        var index = handlers.indexOf(handler);
        if (index >= 0) {
          // Clean up if this was the last listener.
          if (handlers.length == 1)
            delete this.listeners_[type];
          else
            handlers.splice(index, 1);
        }
      }
    }
407229
def remove_ephemeral_listener(self, uid):
        """"""
        self.ephemeral_listeners[:] = (listener for listener in self.ephemeral_listeners
                                       if listener['uid'] != uid)
953843
function listener({ target }) {
        target.removeEventListener(TRANSITION_END, listener);

        if (++ran === pending) {
            ended = true;
            classList.remove(className);

            if (cb) {
                cb();
            }
        }
    }
1003046
public function removeListener( $event, EventListener $listener = null ) {

		$event = strtolower( $event );

		if ( !$this->hasEvent( $event ) ) {
			return;
		}

		if ( $listener !== null ) {
			foreach ( $this->dispatchableListeners[$event] as $key => $dispatchableListener ) {
				if ( $dispatchableListener == $listener ) {
					unset( $this->dispatchableListeners[$event][$key] );
				}
			}
		}

		if ( $listener === null || $this->dispatchableListeners[$event] === array() ) {
			unset( $this->dispatchableListeners[$event] );
		}
	}
601024
public function removeListener($event, $callback)
    {
        if (false === isset($this->listeners[$event])) {

            return;
        }

        $key = array_search($callback, $this->listeners[$event]);
        if ($key !== false) {
            unset($this->listeners[$event][$key]);

            if (0 === count($this->listeners[$event])) {
                unset($this->listeners[$event]);
            }
        }
    }
646741
function clearListeners(context) {
		if (context == null) { throw new Error('clearListeners: context must be provided.'); }
		// notify for every listener we throw out.
		var removedListeners, trackRemovals = false;
		if (this._emitterMetaEventsOn === true) {
			trackRemovals = true;
			removedListeners = [];
		}
		this._emitterListeners.filterAll(function(record) {
			var keepListener = record.registeredContext !== context;
			if (trackRemovals && keepListener === false) {
				removedListeners.push(record);
			}
			return keepListener;
		});
		if (trackRemovals && removedListeners.length > 0) {
			notifyRemoves(this, removedListeners);
		}
	}
360503
function remove_listener(event/*, listener*/) {

			// Ignore if not tcn event
			if(NoPg.isLocalEventName(event)) {
				return;
			}

			event = NoPg.parseEventName(event);

			// Stringifying back the event normalizes the original event name
			var event_name = NoPg.stringifyEventName(event);

			var channel_name = NoPg.parseTCNChannelName(event);

			counter[event_name] -= 1;
			if(counter[event_name] === 0) {
				//debug.log('Stopped listening channel ' + channel_name + ' for ' + event_name);
				self._db.removeListener(channel_name, tcn_listeners[event_name]);
				delete counter[event_name];
			}

		}
116871
function offListeners(listeners, event, callback)
  {
    if (listeners && event in listeners)
    {
      var eventListeners = listeners[ event ];
      var next, node = eventListeners.next;

      while (node !== eventListeners)
      {
        next = node.next;

        if (node.callback === callback)
        {
          node.remove();
        }

        node = next;
      }
    }
  }
603634
public function removeListener($eventName, $listener = null)
    {
        $eventName = $this->cleanEventName($eventName);

        if (!array_key_exists($eventName, $this->_list)) {
            return false;
        }

        foreach ($this->_list[$eventName] as $index => $eventData) {

            if ($eventData[1] === $listener) {
                unset($this->_list[$eventName][$index]);
                return true;
            }
        }

        return false;
    }